# -*- coding: utf-8 -*-
#---------------------------------------------------------------------------
# Copyright 2020 VMware, Inc.  All rights reserved.

# AUTO GENERATED FILE -- DO NOT MODIFY!
#
# vAPI stub file for package com.vmware.nsx.model.
#---------------------------------------------------------------------------

"""


"""

__author__ = 'VMware, Inc.'
__docformat__ = 'restructuredtext en'

import sys

from vmware.vapi.bindings import type
from vmware.vapi.bindings.converter import TypeConverter
from vmware.vapi.bindings.enum import Enum
from vmware.vapi.bindings.error import VapiError
from vmware.vapi.bindings.struct import VapiStruct
from vmware.vapi.bindings.stub import (
    ApiInterfaceStub, StubFactoryBase, VapiInterface)
from vmware.vapi.bindings.common import raise_core_exception
from vmware.vapi.data.validator import (UnionValidator, HasFieldsOfValidator)
from vmware.vapi.exception import CoreException
from vmware.vapi.lib.constants import TaskType
from vmware.vapi.lib.rest import OperationRestMetadata


class ALGTypeNSService(VapiStruct):
    """
    An NSService element that represents an ALG protocol

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "ALGTypeNSService"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    ALG_ORACLE_TNS = "ORACLE_TNS"
    """


    """
    ALG_FTP = "FTP"
    """


    """
    ALG_SUN_RPC_TCP = "SUN_RPC_TCP"
    """


    """
    ALG_SUN_RPC_UDP = "SUN_RPC_UDP"
    """


    """
    ALG_MS_RPC_TCP = "MS_RPC_TCP"
    """


    """
    ALG_MS_RPC_UDP = "MS_RPC_UDP"
    """


    """
    ALG_NBNS_BROADCAST = "NBNS_BROADCAST"
    """


    """
    ALG_NBDG_BROADCAST = "NBDG_BROADCAST"
    """


    """
    ALG_TFTP = "TFTP"
    """


    """



    _canonical_to_pep_names = {
                            'alg': 'alg',
                            'destination_ports': 'destination_ports',
                            'source_ports': 'source_ports',
                            'resource_type': 'resource_type',
                            }

    def __init__(self,
                 alg=None,
                 destination_ports=None,
                 source_ports=None,
                 resource_type='ALGTypeNSService',
                ):
        """
        :type  alg: :class:`str` or ``None``
        :param alg: Possible values are: 
            
            * :attr:`ALGTypeNSService.ALG_ORACLE_TNS`
            * :attr:`ALGTypeNSService.ALG_FTP`
            * :attr:`ALGTypeNSService.ALG_SUN_RPC_TCP`
            * :attr:`ALGTypeNSService.ALG_SUN_RPC_UDP`
            * :attr:`ALGTypeNSService.ALG_MS_RPC_TCP`
            * :attr:`ALGTypeNSService.ALG_MS_RPC_UDP`
            * :attr:`ALGTypeNSService.ALG_NBNS_BROADCAST`
            * :attr:`ALGTypeNSService.ALG_NBDG_BROADCAST`
            * :attr:`ALGTypeNSService.ALG_TFTP`
            
            The Application Layer Gateway (ALG) protocol. Please note, protocol
            NBNS_BROADCAST and NBDG_BROADCAST are deprecated. Please use UDP
            protocol and create L4 Port Set type of service instead.
        :type  destination_ports: :class:`list` of :class:`str` or ``None``
        :param destination_ports: The destination_port cannot be empty and must be a single value.
            format: port-or-range
        :type  source_ports: :class:`list` of :class:`str` or ``None``
        :param source_ports: Source ports format: port-or-range
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`NSServiceElement.RESOURCE_TYPE_ETHERTYPENSSERVICE`
            * :attr:`NSServiceElement.RESOURCE_TYPE_IPPROTOCOLNSSERVICE`
            * :attr:`NSServiceElement.RESOURCE_TYPE_IGMPTYPENSSERVICE`
            * :attr:`NSServiceElement.RESOURCE_TYPE_ICMPTYPENSSERVICE`
            * :attr:`NSServiceElement.RESOURCE_TYPE_ALGTYPENSSERVICE`
            * :attr:`NSServiceElement.RESOURCE_TYPE_L4PORTSETNSSERVICE`
            
             The specific type of NSServiceElement
        """
        self.alg = alg
        self.destination_ports = destination_ports
        self.source_ports = source_ports
        self._resource_type = resource_type
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

ALGTypeNSService._set_binding_type(type.StructType(
    'com.vmware.nsx.model.ALG_type_NS_service', {
        'alg': type.OptionalType(type.StringType()),
        'destination_ports': type.OptionalType(type.ListType(type.StringType())),
        'source_ports': type.OptionalType(type.ListType(type.StringType())),
        'resource_type': type.StringType(),
    },
    ALGTypeNSService,
    False,
    None))



class AcceptableComponentVersion(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    COMPONENT_TYPE_HOST = "HOST"
    """


    """
    COMPONENT_TYPE_EDGE = "EDGE"
    """


    """
    COMPONENT_TYPE_CCP = "CCP"
    """


    """
    COMPONENT_TYPE_MP = "MP"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'acceptable_versions': 'acceptable_versions',
                            'component_type': 'component_type',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 acceptable_versions=None,
                 component_type=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  acceptable_versions: :class:`list` of :class:`str` or ``None``
        :param acceptable_versions: List of component versions
        :type  component_type: :class:`str` or ``None``
        :param component_type: Possible values are: 
            
            * :attr:`AcceptableComponentVersion.COMPONENT_TYPE_HOST`
            * :attr:`AcceptableComponentVersion.COMPONENT_TYPE_EDGE`
            * :attr:`AcceptableComponentVersion.COMPONENT_TYPE_CCP`
            * :attr:`AcceptableComponentVersion.COMPONENT_TYPE_MP`
            
             Node type
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.acceptable_versions = acceptable_versions
        self.component_type = component_type
        VapiStruct.__init__(self)


AcceptableComponentVersion._set_binding_type(type.StructType(
    'com.vmware.nsx.model.acceptable_component_version', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'acceptable_versions': type.OptionalType(type.ListType(type.StringType())),
        'component_type': type.OptionalType(type.StringType()),
    },
    AcceptableComponentVersion,
    False,
    None))



class AcceptableComponentVersionList(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'results': 'results',
                            }

    def __init__(self,
                 results=None,
                ):
        """
        :type  results: :class:`list` of :class:`AcceptableComponentVersion` or ``None``
        :param results: Acceptable version whitelist for different components
        """
        self.results = results
        VapiStruct.__init__(self)


AcceptableComponentVersionList._set_binding_type(type.StructType(
    'com.vmware.nsx.model.acceptable_component_version_list', {
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'AcceptableComponentVersion'))),
    },
    AcceptableComponentVersionList,
    False,
    None))



class ActionableResource(VapiStruct):
    """
    Resources managed during restore process

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'ip_address': 'ip_address',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 ip_address=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  ip_address: :class:`str` or ``None``
        :param ip_address: A resource reference on which actions can be performed format:
            hostname-or-ip
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.ip_address = ip_address
        VapiStruct.__init__(self)


ActionableResource._set_binding_type(type.StructType(
    'com.vmware.nsx.model.actionable_resource', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'ip_address': type.OptionalType(type.StringType()),
    },
    ActionableResource,
    False,
    None))



class ActionableResourceListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`ActionableResource` or ``None``
        :param results: List results
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


ActionableResourceListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.actionable_resource_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ActionableResource'))),
    },
    ActionableResourceListResult,
    False,
    None))



class AddClusterNodeSpec(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'controller_role_config': 'controller_role_config',
                            'display_name': 'display_name',
                            'external_id': 'external_id',
                            'mgr_role_config': 'mgr_role_config',
                            }

    def __init__(self,
                 controller_role_config=None,
                 display_name=None,
                 external_id=None,
                 mgr_role_config=None,
                ):
        """
        :type  controller_role_config: :class:`AddControllerNodeSpec` or ``None``
        :param controller_role_config: 
        :type  display_name: :class:`str` or ``None``
        :param display_name: Display name for the node
        :type  external_id: :class:`str` or ``None``
        :param external_id: External identifier of the node
        :type  mgr_role_config: :class:`AddManagementNodeSpec` or ``None``
        :param mgr_role_config: 
        """
        self.controller_role_config = controller_role_config
        self.display_name = display_name
        self.external_id = external_id
        self.mgr_role_config = mgr_role_config
        VapiStruct.__init__(self)


AddClusterNodeSpec._set_binding_type(type.StructType(
    'com.vmware.nsx.model.add_cluster_node_spec', {
        'controller_role_config': type.OptionalType(type.ReferenceType(__name__, 'AddControllerNodeSpec')),
        'display_name': type.OptionalType(type.StringType()),
        'external_id': type.OptionalType(type.StringType()),
        'mgr_role_config': type.OptionalType(type.ReferenceType(__name__, 'AddManagementNodeSpec')),
    },
    AddClusterNodeSpec,
    False,
    None))



class AddClusterNodeVMInfo(VapiStruct):
    """
    Contains a list of cluster node VM deployment requests and optionally a
    clustering configuration.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'clustering_config': 'clustering_config',
                            'deployment_requests': 'deployment_requests',
                            }

    def __init__(self,
                 clustering_config=None,
                 deployment_requests=None,
                ):
        """
        :type  clustering_config: :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param clustering_config: This property is deprecated since ClusteringConfig is no longer
            needed for auto-installation and will be ignored if provided.
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`ClusteringConfig`. When methods return a value of this
            class as a return value, the attribute will contain all the
            attributes defined in :class:`ClusteringConfig`.
        :type  deployment_requests: :class:`list` of :class:`ClusterNodeVMDeploymentRequest` or ``None``
        :param deployment_requests: Cluster node VM deployment requests to be deployed by the Manager.
        """
        self.clustering_config = clustering_config
        self.deployment_requests = deployment_requests
        VapiStruct.__init__(self)


AddClusterNodeVMInfo._set_binding_type(type.StructType(
    'com.vmware.nsx.model.add_cluster_node_VM_info', {
        'clustering_config': type.OptionalType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'ClusteringConfig')])),
        'deployment_requests': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ClusterNodeVMDeploymentRequest'))),
    },
    AddClusterNodeVMInfo,
    False,
    None))



class AddControllerNodeSpec(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    TYPE_ADDCONTROLLERNODESPEC = "AddControllerNodeSpec"
    """


    """



    _canonical_to_pep_names = {
                            'clustering_params': 'clustering_params',
                            'control_plane_server_certificate': 'control_plane_server_certificate',
                            'host_msg_client_info': 'host_msg_client_info',
                            'mpa_msg_client_info': 'mpa_msg_client_info',
                            'node_id': 'node_id',
                            'type': 'type',
                            }

    def __init__(self,
                 clustering_params=None,
                 control_plane_server_certificate=None,
                 host_msg_client_info=None,
                 mpa_msg_client_info=None,
                 node_id=None,
                 type=None,
                ):
        """
        :type  clustering_params: :class:`ClusteringInfo` or ``None``
        :param clustering_params: The details of the controller node required for cluster
            initialization or joining to an existing cluster. If this property
            is set, the node will be added to an existing cluster or used to
            create a new cluster. Otherwise no clustering operation/s will be
            performed.
        :type  control_plane_server_certificate: :class:`str` or ``None``
        :param control_plane_server_certificate: Deprecated. Do not supply a value for this property.
        :type  host_msg_client_info: :class:`MsgClientInfo` or ``None``
        :param host_msg_client_info: 
        :type  mpa_msg_client_info: :class:`MsgClientInfo` or ``None``
        :param mpa_msg_client_info: 
        :type  node_id: :class:`str` or ``None``
        :param node_id: Only use this if an id for the node already exists with MP. If not
            specified, then the node_id will be set to a random id.
        :type  type: :class:`str` or ``None``
        :param type: Possible values are: 
            
            * :attr:`AddControllerNodeSpec.TYPE_ADDCONTROLLERNODESPEC`
            
             must be set to AddControllerNodeSpec
        """
        self.clustering_params = clustering_params
        self.control_plane_server_certificate = control_plane_server_certificate
        self.host_msg_client_info = host_msg_client_info
        self.mpa_msg_client_info = mpa_msg_client_info
        self.node_id = node_id
        self.type = type
        VapiStruct.__init__(self)


AddControllerNodeSpec._set_binding_type(type.StructType(
    'com.vmware.nsx.model.add_controller_node_spec', {
        'clustering_params': type.OptionalType(type.ReferenceType(__name__, 'ClusteringInfo')),
        'control_plane_server_certificate': type.OptionalType(type.StringType()),
        'host_msg_client_info': type.OptionalType(type.ReferenceType(__name__, 'MsgClientInfo')),
        'mpa_msg_client_info': type.OptionalType(type.ReferenceType(__name__, 'MsgClientInfo')),
        'node_id': type.OptionalType(type.StringType()),
        'type': type.OptionalType(type.StringType()),
    },
    AddControllerNodeSpec,
    False,
    None))



class AddIntelligenceClusterNodeVMInfo(VapiStruct):
    """
    Contains a list of NSX-Intelligence cluster node VM deployment requests and
    optionally a clustering configuration.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'deployment_requests': 'deployment_requests',
                            }

    def __init__(self,
                 deployment_requests=None,
                ):
        """
        :type  deployment_requests: :class:`list` of :class:`IntelligenceClusterNodeVMDeploymentRequest` or ``None``
        :param deployment_requests: Intelligence Cluster node VM deployment requests to be deployed by
            NSX.
        """
        self.deployment_requests = deployment_requests
        VapiStruct.__init__(self)


AddIntelligenceClusterNodeVMInfo._set_binding_type(type.StructType(
    'com.vmware.nsx.model.add_intelligence_cluster_node_VM_info', {
        'deployment_requests': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IntelligenceClusterNodeVMDeploymentRequest'))),
    },
    AddIntelligenceClusterNodeVMInfo,
    False,
    None))



class AddManagementNodeSpec(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    TYPE_ADDMANAGEMENTNODESPEC = "AddManagementNodeSpec"
    """


    """



    _canonical_to_pep_names = {
                            'cert_thumbprint': 'cert_thumbprint',
                            'mpa_msg_client_info': 'mpa_msg_client_info',
                            'password': 'password',
                            'remote_address': 'remote_address',
                            'type': 'type',
                            'user_name': 'user_name',
                            }

    def __init__(self,
                 cert_thumbprint=None,
                 mpa_msg_client_info=None,
                 password=None,
                 remote_address=None,
                 type=None,
                 user_name=None,
                ):
        """
        :type  cert_thumbprint: :class:`str` or ``None``
        :param cert_thumbprint: The certificate thumbprint of the remote node.
        :type  mpa_msg_client_info: :class:`MsgClientInfo` or ``None``
        :param mpa_msg_client_info: 
        :type  password: :class:`str` or ``None``
        :param password: The password to be used to authenticate with the remote node.
        :type  remote_address: :class:`str` or ``None``
        :param remote_address: The host address of the remote node to which to send this join
            request. format: ip
        :type  type: :class:`str` or ``None``
        :param type: Possible values are: 
            
            * :attr:`AddManagementNodeSpec.TYPE_ADDMANAGEMENTNODESPEC`
            
             must be set to AddManagementNodeSpec
        :type  user_name: :class:`str` or ``None``
        :param user_name: The username to be used to authenticate with the remote node.
        """
        self.cert_thumbprint = cert_thumbprint
        self.mpa_msg_client_info = mpa_msg_client_info
        self.password = password
        self.remote_address = remote_address
        self.type = type
        self.user_name = user_name
        VapiStruct.__init__(self)


AddManagementNodeSpec._set_binding_type(type.StructType(
    'com.vmware.nsx.model.add_management_node_spec', {
        'cert_thumbprint': type.OptionalType(type.StringType()),
        'mpa_msg_client_info': type.OptionalType(type.ReferenceType(__name__, 'MsgClientInfo')),
        'password': type.OptionalType(type.StringType()),
        'remote_address': type.OptionalType(type.StringType()),
        'type': type.OptionalType(type.StringType()),
        'user_name': type.OptionalType(type.StringType()),
    },
    AddManagementNodeSpec,
    False,
    None))



class AddressBindingEntry(VapiStruct):
    """
    An address binding entry is a combination of the IP-MAC-VLAN binding for a
    logical port. The address bindings can be obtained via various methods like
    ARP snooping, DHCP snooping etc. or by user configuration.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    SOURCE_INVALID = "INVALID"
    """


    """
    SOURCE_UNKNOWN = "UNKNOWN"
    """


    """
    SOURCE_USER_DEFINED = "USER_DEFINED"
    """


    """
    SOURCE_ARP_SNOOPING = "ARP_SNOOPING"
    """


    """
    SOURCE_DHCP_SNOOPING = "DHCP_SNOOPING"
    """


    """
    SOURCE_VM_TOOLS = "VM_TOOLS"
    """


    """
    SOURCE_ND_SNOOPING = "ND_SNOOPING"
    """


    """
    SOURCE_DHCPV6_SNOOPING = "DHCPV6_SNOOPING"
    """


    """
    SOURCE_VM_TOOLS_V6 = "VM_TOOLS_V6"
    """


    """



    _canonical_to_pep_names = {
                            'binding': 'binding',
                            'binding_timestamp': 'binding_timestamp',
                            'source': 'source',
                            }

    def __init__(self,
                 binding=None,
                 binding_timestamp=None,
                 source=None,
                ):
        """
        :type  binding: :class:`PacketAddressClassifier` or ``None``
        :param binding: Combination of IP-MAC-VLAN binding
        :type  binding_timestamp: :class:`long` or ``None``
        :param binding_timestamp: Timestamp at which the binding was discovered via snooping or
            manually specified by the user format: int64
        :type  source: :class:`str` or ``None``
        :param source: Possible values are: 
            
            * :attr:`AddressBindingEntry.SOURCE_INVALID`
            * :attr:`AddressBindingEntry.SOURCE_UNKNOWN`
            * :attr:`AddressBindingEntry.SOURCE_USER_DEFINED`
            * :attr:`AddressBindingEntry.SOURCE_ARP_SNOOPING`
            * :attr:`AddressBindingEntry.SOURCE_DHCP_SNOOPING`
            * :attr:`AddressBindingEntry.SOURCE_VM_TOOLS`
            * :attr:`AddressBindingEntry.SOURCE_ND_SNOOPING`
            * :attr:`AddressBindingEntry.SOURCE_DHCPV6_SNOOPING`
            * :attr:`AddressBindingEntry.SOURCE_VM_TOOLS_V6`
            
             Source from which the address binding entry was obtained
        """
        self.binding = binding
        self.binding_timestamp = binding_timestamp
        self.source = source
        VapiStruct.__init__(self)


AddressBindingEntry._set_binding_type(type.StructType(
    'com.vmware.nsx.model.address_binding_entry', {
        'binding': type.OptionalType(type.ReferenceType(__name__, 'PacketAddressClassifier')),
        'binding_timestamp': type.OptionalType(type.IntegerType()),
        'source': type.OptionalType(type.StringType()),
    },
    AddressBindingEntry,
    False,
    None))



class AdvanceClusterRestoreInput(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'id': 'id',
                            'resources': 'resources',
                            }

    def __init__(self,
                 id=None,
                 resources=None,
                ):
        """
        :type  id: :class:`str` or ``None``
        :param id: Unique id of an instruction (as returned by the GET /restore/status
            call) for which input is to be provided
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  resources: :class:`list` of :class:`SelectableResourceReference` or ``None``
        :param resources: List of resources for which the instruction is applicable.
        """
        self.id = id
        self.resources = resources
        VapiStruct.__init__(self)


AdvanceClusterRestoreInput._set_binding_type(type.StructType(
    'com.vmware.nsx.model.advance_cluster_restore_input', {
        'id': type.OptionalType(type.StringType()),
        'resources': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'SelectableResourceReference'))),
    },
    AdvanceClusterRestoreInput,
    False,
    None))



class AdvanceClusterRestoreRequest(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'data': 'data',
                            }

    def __init__(self,
                 data=None,
                ):
        """
        :type  data: :class:`list` of :class:`AdvanceClusterRestoreInput` or ``None``
        :param data: List of instructions and their associated data
        """
        self.data = data
        VapiStruct.__init__(self)


AdvanceClusterRestoreRequest._set_binding_type(type.StructType(
    'com.vmware.nsx.model.advance_cluster_restore_request', {
        'data': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'AdvanceClusterRestoreInput'))),
    },
    AdvanceClusterRestoreRequest,
    False,
    None))



class AdvertiseRule(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    ACTION_DENY = "DENY"
    """


    """
    ACTION_ALLOW = "ALLOW"
    """


    """



    _canonical_to_pep_names = {
                            'action': 'action',
                            'description': 'description',
                            'display_name': 'display_name',
                            'networks': 'networks',
                            'rule_filter': 'rule_filter',
                            }

    def __init__(self,
                 action=None,
                 description=None,
                 display_name=None,
                 networks=None,
                 rule_filter=None,
                ):
        """
        :type  action: :class:`str` or ``None``
        :param action: Possible values are: 
            
            * :attr:`AdvertiseRule.ACTION_DENY`
            * :attr:`AdvertiseRule.ACTION_ALLOW`
            
            ALLOW action enables the advertisment and DENY action disables the
            advertisement of a filtered routes to the connected TIER0 router.
        :type  description: :class:`str` or ``None``
        :param description: Description
        :type  display_name: :class:`str` or ``None``
        :param display_name: Display name
        :type  networks: :class:`list` of :class:`str` or ``None``
        :param networks: network(CIDR) to be routed format: ip-cidr-block
        :type  rule_filter: :class:`AdvertisementRuleFilter` or ``None``
        :param rule_filter: Rule filter for the advertise rule
        """
        self.action = action
        self.description = description
        self.display_name = display_name
        self.networks = networks
        self.rule_filter = rule_filter
        VapiStruct.__init__(self)


AdvertiseRule._set_binding_type(type.StructType(
    'com.vmware.nsx.model.advertise_rule', {
        'action': type.OptionalType(type.StringType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'networks': type.OptionalType(type.ListType(type.StringType())),
        'rule_filter': type.OptionalType(type.ReferenceType(__name__, 'AdvertisementRuleFilter')),
    },
    AdvertiseRule,
    False,
    None))



class AdvertiseRuleList(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'logical_router_id': 'logical_router_id',
                            'rules': 'rules',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 logical_router_id=None,
                 rules=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  logical_router_id: :class:`str` or ``None``
        :param logical_router_id: Logical router id
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  rules: :class:`list` of :class:`AdvertiseRule` or ``None``
        :param rules: List of advertisement rules
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.logical_router_id = logical_router_id
        self.rules = rules
        VapiStruct.__init__(self)


AdvertiseRuleList._set_binding_type(type.StructType(
    'com.vmware.nsx.model.advertise_rule_list', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'logical_router_id': type.OptionalType(type.StringType()),
        'rules': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'AdvertiseRule'))),
    },
    AdvertiseRuleList,
    False,
    None))



class AdvertisementConfig(VapiStruct):
    """
    Advertisement config for different types of routes which need to be
    advertised from TIER1 logical router to the linked TIER0 logical router

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'advertise_dns_forwarder': 'advertise_dns_forwarder',
                            'advertise_ipsec_local_ip': 'advertise_ipsec_local_ip',
                            'advertise_lb_snat_ip': 'advertise_lb_snat_ip',
                            'advertise_lb_vip': 'advertise_lb_vip',
                            'advertise_nat_routes': 'advertise_nat_routes',
                            'advertise_nsx_connected_routes': 'advertise_nsx_connected_routes',
                            'advertise_static_routes': 'advertise_static_routes',
                            'enabled': 'enabled',
                            'logical_router_id': 'logical_router_id',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 advertise_dns_forwarder=None,
                 advertise_ipsec_local_ip=None,
                 advertise_lb_snat_ip=None,
                 advertise_lb_vip=None,
                 advertise_nat_routes=None,
                 advertise_nsx_connected_routes=None,
                 advertise_static_routes=None,
                 enabled=None,
                 logical_router_id=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  advertise_dns_forwarder: :class:`bool` or ``None``
        :param advertise_dns_forwarder: Flag to advertise all routes of dns forwarder listener ips and
            source ips
        :type  advertise_ipsec_local_ip: :class:`bool` or ``None``
        :param advertise_ipsec_local_ip: Flag to advertise all IPSec VPN local endpoint ips to linked TIER0
            logical router
        :type  advertise_lb_snat_ip: :class:`bool` or ``None``
        :param advertise_lb_snat_ip: Flag to advertise all lb SNAT ips
        :type  advertise_lb_vip: :class:`bool` or ``None``
        :param advertise_lb_vip: Flag to advertise lb vip ips
        :type  advertise_nat_routes: :class:`bool` or ``None``
        :param advertise_nat_routes: Flag to advertise all routes of nat
        :type  advertise_nsx_connected_routes: :class:`bool` or ``None``
        :param advertise_nsx_connected_routes: Flag to advertise all connected routes
        :type  advertise_static_routes: :class:`bool` or ``None``
        :param advertise_static_routes: Flag to advertise all static routes
        :type  enabled: :class:`bool` or ``None``
        :param enabled: Flag to enable this configuration
        :type  logical_router_id: :class:`str` or ``None``
        :param logical_router_id: TIER1 logical router id on which to enable this configuration
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.advertise_dns_forwarder = advertise_dns_forwarder
        self.advertise_ipsec_local_ip = advertise_ipsec_local_ip
        self.advertise_lb_snat_ip = advertise_lb_snat_ip
        self.advertise_lb_vip = advertise_lb_vip
        self.advertise_nat_routes = advertise_nat_routes
        self.advertise_nsx_connected_routes = advertise_nsx_connected_routes
        self.advertise_static_routes = advertise_static_routes
        self.enabled = enabled
        self.logical_router_id = logical_router_id
        VapiStruct.__init__(self)


AdvertisementConfig._set_binding_type(type.StructType(
    'com.vmware.nsx.model.advertisement_config', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'advertise_dns_forwarder': type.OptionalType(type.BooleanType()),
        'advertise_ipsec_local_ip': type.OptionalType(type.BooleanType()),
        'advertise_lb_snat_ip': type.OptionalType(type.BooleanType()),
        'advertise_lb_vip': type.OptionalType(type.BooleanType()),
        'advertise_nat_routes': type.OptionalType(type.BooleanType()),
        'advertise_nsx_connected_routes': type.OptionalType(type.BooleanType()),
        'advertise_static_routes': type.OptionalType(type.BooleanType()),
        'enabled': type.OptionalType(type.BooleanType()),
        'logical_router_id': type.OptionalType(type.StringType()),
    },
    AdvertisementConfig,
    False,
    None))



class AdvertisementRuleFilter(VapiStruct):
    """
    To filter the routes advertised by the TIER1 LR to TIER0 LR. Filtering will
    be based on the type of route and the prefix operator configured.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    MATCH_ROUTE_TYPES_ANY = "ANY"
    """


    """
    MATCH_ROUTE_TYPES_STATIC = "STATIC"
    """


    """
    MATCH_ROUTE_TYPES_T1_STATIC = "T1_STATIC"
    """


    """
    MATCH_ROUTE_TYPES_NSX_CONNECTED = "NSX_CONNECTED"
    """


    """
    MATCH_ROUTE_TYPES_T1_CONNECTED = "T1_CONNECTED"
    """


    """
    MATCH_ROUTE_TYPES_T1_NAT = "T1_NAT"
    """


    """
    MATCH_ROUTE_TYPES_T1_LB_VIP = "T1_LB_VIP"
    """


    """
    MATCH_ROUTE_TYPES_T1_LB_SNAT = "T1_LB_SNAT"
    """


    """
    MATCH_ROUTE_TYPES_T1_DNSFORWARDER = "T1_DNSFORWARDER"
    """


    """
    MATCH_ROUTE_TYPES_T1_IPSEC_LOCAL_IP = "T1_IPSEC_LOCAL_IP"
    """


    """
    PREFIX_OPERATOR_GE = "GE"
    """


    """
    PREFIX_OPERATOR_EQ = "EQ"
    """


    """



    _canonical_to_pep_names = {
                            'match_route_types': 'match_route_types',
                            'prefix_operator': 'prefix_operator',
                            }

    def __init__(self,
                 match_route_types=None,
                 prefix_operator=None,
                ):
        """
        :type  match_route_types: :class:`list` of :class:`str` or ``None``
        :param match_route_types: Possible values are: 
            
            * :attr:`AdvertisementRuleFilter.MATCH_ROUTE_TYPES_ANY`
            * :attr:`AdvertisementRuleFilter.MATCH_ROUTE_TYPES_STATIC`
            * :attr:`AdvertisementRuleFilter.MATCH_ROUTE_TYPES_T1_STATIC`
            * :attr:`AdvertisementRuleFilter.MATCH_ROUTE_TYPES_NSX_CONNECTED`
            * :attr:`AdvertisementRuleFilter.MATCH_ROUTE_TYPES_T1_CONNECTED`
            * :attr:`AdvertisementRuleFilter.MATCH_ROUTE_TYPES_T1_NAT`
            * :attr:`AdvertisementRuleFilter.MATCH_ROUTE_TYPES_T1_LB_VIP`
            * :attr:`AdvertisementRuleFilter.MATCH_ROUTE_TYPES_T1_LB_SNAT`
            * :attr:`AdvertisementRuleFilter.MATCH_ROUTE_TYPES_T1_DNSFORWARDER`
            *
              :attr:`AdvertisementRuleFilter.MATCH_ROUTE_TYPES_T1_IPSEC_LOCAL_IP`
            
             Array of route types to filter routes
        :type  prefix_operator: :class:`str` or ``None``
        :param prefix_operator: Possible values are: 
            
            * :attr:`AdvertisementRuleFilter.PREFIX_OPERATOR_GE`
            * :attr:`AdvertisementRuleFilter.PREFIX_OPERATOR_EQ`
            
            GE prefix operator filters all the routes having network subset of
            any of the networks configured in Advertise rule. EQ prefix
            operator filter all the routes having network equal to any of the
            network configured in Advertise rule.
        """
        self.match_route_types = match_route_types
        self.prefix_operator = prefix_operator
        VapiStruct.__init__(self)


AdvertisementRuleFilter._set_binding_type(type.StructType(
    'com.vmware.nsx.model.advertisement_rule_filter', {
        'match_route_types': type.OptionalType(type.ListType(type.StringType())),
        'prefix_operator': type.OptionalType(type.StringType()),
    },
    AdvertisementRuleFilter,
    False,
    None))



class AgentStatus(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    NAME_AGENT = "NSX_AGENT"
    """


    """
    NAME_OPSAGENT = "NSX_OPSAGENT"
    """


    """
    NAME_CFGAGENT = "NSX_CFGAGENT"
    """


    """
    NAME_NESTDB = "NSX_NESTDB"
    """


    """
    STATUS_UP = "UP"
    """


    """
    STATUS_DOWN = "DOWN"
    """


    """
    STATUS_UNKNOWN = "UNKNOWN"
    """


    """



    _canonical_to_pep_names = {
                            'name': 'name',
                            'status': 'status',
                            }

    def __init__(self,
                 name=None,
                 status=None,
                ):
        """
        :type  name: :class:`str` or ``None``
        :param name: Possible values are: 
            
            * :attr:`AgentStatus.NAME_AGENT`
            * :attr:`AgentStatus.NAME_OPSAGENT`
            * :attr:`AgentStatus.NAME_CFGAGENT`
            * :attr:`AgentStatus.NAME_NESTDB`
            
             Agent name
        :type  status: :class:`str` or ``None``
        :param status: Possible values are: 
            
            * :attr:`AgentStatus.STATUS_UP`
            * :attr:`AgentStatus.STATUS_DOWN`
            * :attr:`AgentStatus.STATUS_UNKNOWN`
            
             Agent status
        """
        self.name = name
        self.status = status
        VapiStruct.__init__(self)


AgentStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.agent_status', {
        'name': type.OptionalType(type.StringType()),
        'status': type.OptionalType(type.StringType()),
    },
    AgentStatus,
    False,
    None))



class AgentStatusCount(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATUS_UP = "UP"
    """


    """
    STATUS_DOWN = "DOWN"
    """


    """
    STATUS_UNKNOWN = "UNKNOWN"
    """


    """



    _canonical_to_pep_names = {
                            'agents': 'agents',
                            'down_count': 'down_count',
                            'status': 'status',
                            'up_count': 'up_count',
                            }

    def __init__(self,
                 agents=None,
                 down_count=None,
                 status=None,
                 up_count=None,
                ):
        """
        :type  agents: :class:`list` of :class:`AgentStatus` or ``None``
        :param agents: List of agent statuses belonging to the transport node
        :type  down_count: :class:`long` or ``None``
        :param down_count: Down count format: int32
        :type  status: :class:`str` or ``None``
        :param status: Possible values are: 
            
            * :attr:`AgentStatusCount.STATUS_UP`
            * :attr:`AgentStatusCount.STATUS_DOWN`
            * :attr:`AgentStatusCount.STATUS_UNKNOWN`
            
             Roll-up agent status
        :type  up_count: :class:`long` or ``None``
        :param up_count: Up count format: int32
        """
        self.agents = agents
        self.down_count = down_count
        self.status = status
        self.up_count = up_count
        VapiStruct.__init__(self)


AgentStatusCount._set_binding_type(type.StructType(
    'com.vmware.nsx.model.agent_status_count', {
        'agents': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'AgentStatus'))),
        'down_count': type.OptionalType(type.IntegerType()),
        'status': type.OptionalType(type.StringType()),
        'up_count': type.OptionalType(type.IntegerType()),
    },
    AgentStatusCount,
    False,
    None))



class AggregatedDataCounter(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'rx_bytes': 'rx_bytes',
                            'rx_packets': 'rx_packets',
                            'tx_bytes': 'tx_bytes',
                            'tx_packets': 'tx_packets',
                            }

    def __init__(self,
                 rx_bytes=None,
                 rx_packets=None,
                 tx_bytes=None,
                 tx_packets=None,
                ):
        """
        :type  rx_bytes: :class:`DataCounter` or ``None``
        :param rx_bytes: 
        :type  rx_packets: :class:`DataCounter` or ``None``
        :param rx_packets: 
        :type  tx_bytes: :class:`DataCounter` or ``None``
        :param tx_bytes: 
        :type  tx_packets: :class:`DataCounter` or ``None``
        :param tx_packets: 
        """
        self.rx_bytes = rx_bytes
        self.rx_packets = rx_packets
        self.tx_bytes = tx_bytes
        self.tx_packets = tx_packets
        VapiStruct.__init__(self)


AggregatedDataCounter._set_binding_type(type.StructType(
    'com.vmware.nsx.model.aggregated_data_counter', {
        'rx_bytes': type.OptionalType(type.ReferenceType(__name__, 'DataCounter')),
        'rx_packets': type.OptionalType(type.ReferenceType(__name__, 'DataCounter')),
        'tx_bytes': type.OptionalType(type.ReferenceType(__name__, 'DataCounter')),
        'tx_packets': type.OptionalType(type.ReferenceType(__name__, 'DataCounter')),
    },
    AggregatedDataCounter,
    False,
    None))



class AggregatedDataCounterEx(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'rx_bytes': 'rx_bytes',
                            'rx_packets': 'rx_packets',
                            'tx_bytes': 'tx_bytes',
                            'tx_packets': 'tx_packets',
                            'dropped_by_security_packets': 'dropped_by_security_packets',
                            'mac_learning': 'mac_learning',
                            }

    def __init__(self,
                 rx_bytes=None,
                 rx_packets=None,
                 tx_bytes=None,
                 tx_packets=None,
                 dropped_by_security_packets=None,
                 mac_learning=None,
                ):
        """
        :type  rx_bytes: :class:`DataCounter` or ``None``
        :param rx_bytes: 
        :type  rx_packets: :class:`DataCounter` or ``None``
        :param rx_packets: 
        :type  tx_bytes: :class:`DataCounter` or ``None``
        :param tx_bytes: 
        :type  tx_packets: :class:`DataCounter` or ``None``
        :param tx_packets: 
        :type  dropped_by_security_packets: :class:`PacketsDroppedBySecurity` or ``None``
        :param dropped_by_security_packets: 
        :type  mac_learning: :class:`MacLearningCounters` or ``None``
        :param mac_learning: 
        """
        self.rx_bytes = rx_bytes
        self.rx_packets = rx_packets
        self.tx_bytes = tx_bytes
        self.tx_packets = tx_packets
        self.dropped_by_security_packets = dropped_by_security_packets
        self.mac_learning = mac_learning
        VapiStruct.__init__(self)


AggregatedDataCounterEx._set_binding_type(type.StructType(
    'com.vmware.nsx.model.aggregated_data_counter_ex', {
        'rx_bytes': type.OptionalType(type.ReferenceType(__name__, 'DataCounter')),
        'rx_packets': type.OptionalType(type.ReferenceType(__name__, 'DataCounter')),
        'tx_bytes': type.OptionalType(type.ReferenceType(__name__, 'DataCounter')),
        'tx_packets': type.OptionalType(type.ReferenceType(__name__, 'DataCounter')),
        'dropped_by_security_packets': type.OptionalType(type.ReferenceType(__name__, 'PacketsDroppedBySecurity')),
        'mac_learning': type.OptionalType(type.ReferenceType(__name__, 'MacLearningCounters')),
    },
    AggregatedDataCounterEx,
    False,
    None))



class AggregatedLogicalRouterPortCounters(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'last_update_timestamp': 'last_update_timestamp',
                            'rx': 'rx',
                            'tx': 'tx',
                            }

    def __init__(self,
                 last_update_timestamp=None,
                 rx=None,
                 tx=None,
                ):
        """
        :type  last_update_timestamp: :class:`long` or ``None``
        :param last_update_timestamp: Timestamp when the data was last updated; unset if data source has
            never updated the data. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  rx: :class:`LogicalRouterPortCounters` or ``None``
        :param rx: 
        :type  tx: :class:`LogicalRouterPortCounters` or ``None``
        :param tx: 
        """
        self.last_update_timestamp = last_update_timestamp
        self.rx = rx
        self.tx = tx
        VapiStruct.__init__(self)


AggregatedLogicalRouterPortCounters._set_binding_type(type.StructType(
    'com.vmware.nsx.model.aggregated_logical_router_port_counters', {
        'last_update_timestamp': type.OptionalType(type.IntegerType()),
        'rx': type.OptionalType(type.ReferenceType(__name__, 'LogicalRouterPortCounters')),
        'tx': type.OptionalType(type.ReferenceType(__name__, 'LogicalRouterPortCounters')),
    },
    AggregatedLogicalRouterPortCounters,
    False,
    None))



class Alarm(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    ALARM_SOURCE_TYPE_INTENT_PATH = "INTENT_PATH"
    """


    """
    ALARM_SOURCE_TYPE_ENTITY_ID = "ENTITY_ID"
    """


    """
    SEVERITY_CRITICAL = "CRITICAL"
    """


    """
    SEVERITY_HIGH = "HIGH"
    """


    """
    SEVERITY_MEDIUM = "MEDIUM"
    """


    """
    SEVERITY_LOW = "LOW"
    """


    """
    STATUS_OPEN = "OPEN"
    """


    """
    STATUS_ACKNOWLEDGED = "ACKNOWLEDGED"
    """


    """
    STATUS_SUPPRESSED = "SUPPRESSED"
    """


    """
    STATUS_RESOLVED = "RESOLVED"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'alarm_source': 'alarm_source',
                            'alarm_source_type': 'alarm_source_type',
                            'entity_id': 'entity_id',
                            'entity_resource_type': 'entity_resource_type',
                            'event_type': 'event_type',
                            'event_type_display_name': 'event_type_display_name',
                            'feature_display_name': 'feature_display_name',
                            'feature_name': 'feature_name',
                            'last_reported_time': 'last_reported_time',
                            'node_display_name': 'node_display_name',
                            'node_id': 'node_id',
                            'node_ip_addresses': 'node_ip_addresses',
                            'node_resource_type': 'node_resource_type',
                            'recommended_action': 'recommended_action',
                            'reoccurrences_while_suppressed': 'reoccurrences_while_suppressed',
                            'resolved_by': 'resolved_by',
                            'resolved_time': 'resolved_time',
                            'severity': 'severity',
                            'status': 'status',
                            'summary': 'summary',
                            'suppress_duration': 'suppress_duration',
                            'suppress_start_time': 'suppress_start_time',
                            'suppressed_by': 'suppressed_by',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 alarm_source=None,
                 alarm_source_type=None,
                 entity_id=None,
                 entity_resource_type=None,
                 event_type=None,
                 event_type_display_name=None,
                 feature_display_name=None,
                 feature_name=None,
                 last_reported_time=None,
                 node_display_name=None,
                 node_id=None,
                 node_ip_addresses=None,
                 node_resource_type=None,
                 recommended_action=None,
                 reoccurrences_while_suppressed=None,
                 resolved_by=None,
                 resolved_time=None,
                 severity=None,
                 status=None,
                 summary=None,
                 suppress_duration=None,
                 suppress_start_time=None,
                 suppressed_by=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Detailed description of Alarm. This is the same detailed
            description as the corresponding Event identified by
            feature_name.event_type.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: ID that uniquely identifies an Alarm.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  alarm_source: :class:`list` of :class:`str` or ``None``
        :param alarm_source: If alarm_source_type = INTENT_PATH, this field will contain a list
            of intent paths for the entity that the event instance applies to.
            If alarm_source_type = ENTITY_ID, this field will contain a list
            with a single item identifying the entity id that the event
            instance applies to.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  alarm_source_type: :class:`str` or ``None``
        :param alarm_source_type: Possible values are: 
            
            * :attr:`Alarm.ALARM_SOURCE_TYPE_INTENT_PATH`
            * :attr:`Alarm.ALARM_SOURCE_TYPE_ENTITY_ID`
            
            Type of alarm source of the Event instance. Can be one of -
            INTENT_PATH, ENTITY_ID.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  entity_id: :class:`str` or ``None``
        :param entity_id: The entity that the Event instance applies to. Note entity_id may
            not be included in a response body. For example, the cpu_high Event
            may not return an entity_id.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  entity_resource_type: :class:`str` or ``None``
        :param entity_resource_type: The entity type that the Event instance applies to.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  event_type: :class:`str` or ``None``
        :param event_type: Name of Event, e.g. manager_cpu_usage_high, certificate_expired.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  event_type_display_name: :class:`str` or ``None``
        :param event_type_display_name: Display name of Event type.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  feature_display_name: :class:`str` or ``None``
        :param feature_display_name: Display name of feature defining this Event.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  feature_name: :class:`str` or ``None``
        :param feature_name: Feature defining this Event, e.g. manager_health, certificates.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_reported_time: :class:`long` or ``None``
        :param last_reported_time: Indicates when the corresponding Event instance was last reported
            in milliseconds since epoch. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  node_display_name: :class:`str` or ``None``
        :param node_display_name: Display name of node that the event instance applies to.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  node_id: :class:`str` or ``None``
        :param node_id: The UUID of the node that the Event instance applies to.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  node_ip_addresses: :class:`list` of :class:`str` or ``None``
        :param node_ip_addresses: IP addresses of node that the event instance applies to.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  node_resource_type: :class:`str` or ``None``
        :param node_resource_type: The resource type of node that the Event instance applies to eg.
            ClusterNodeConfig, HostNode, EdgeNode.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  recommended_action: :class:`str` or ``None``
        :param recommended_action: Recommended action for Alarm. This is the same action as the
            corresponding Event identified by feature_name.event_type.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  reoccurrences_while_suppressed: :class:`long` or ``None``
        :param reoccurrences_while_suppressed: The number of reoccurrences since this alarm has been SUPPRESSED.
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  resolved_by: :class:`str` or ``None``
        :param resolved_by: User ID of the user that set the status value to RESOLVED. This
            value can be SYSTEM to indicate that the system resolved the Alarm,
            for example when the system determines CPU usage is no longer high
            and the cpu_high Alarm is no longer applicable. This property is
            only returned when the status value is RESOLVED.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  resolved_time: :class:`long` or ``None``
        :param resolved_time: Indicates when the Alarm was resolved in milliseconds since epoch.
            This property is only returned when the status value is RESOLVED.
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  severity: :class:`str` or ``None``
        :param severity: Possible values are: 
            
            * :attr:`Alarm.SEVERITY_CRITICAL`
            * :attr:`Alarm.SEVERITY_HIGH`
            * :attr:`Alarm.SEVERITY_MEDIUM`
            * :attr:`Alarm.SEVERITY_LOW`
            
             Severity of the Alarm.Can be one of - CRITICAL, HIGH, MEDIUM, LOW.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  status: :class:`str` or ``None``
        :param status: Possible values are: 
            
            * :attr:`Alarm.STATUS_OPEN`
            * :attr:`Alarm.STATUS_ACKNOWLEDGED`
            * :attr:`Alarm.STATUS_SUPPRESSED`
            * :attr:`Alarm.STATUS_RESOLVED`
            
             Indicate the status which the Alarm is in.
        :type  summary: :class:`str` or ``None``
        :param summary: Summary description of Alarm. This is the same summary description
            as the corresponding Event identified by feature_name.event_type.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  suppress_duration: :class:`long` or ``None``
        :param suppress_duration: The time period between suppress_start_time and suppress_start_time
            + suppress_duration (specified in hours) an Alarm is SUPPRESSED.
            This property is only returned when the status value is SUPPRESSED.
            format: int64
        :type  suppress_start_time: :class:`long` or ``None``
        :param suppress_start_time: Indicates when the Alarm was suppressed in milliseconds since
            epoch. This property is only returned when the status value is
            SUPPRESSED. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  suppressed_by: :class:`str` or ``None``
        :param suppressed_by: User ID of the user that set the status value to SUPPRESSED. This
            property is only returned when the status value is SUPPRESSED.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.alarm_source = alarm_source
        self.alarm_source_type = alarm_source_type
        self.entity_id = entity_id
        self.entity_resource_type = entity_resource_type
        self.event_type = event_type
        self.event_type_display_name = event_type_display_name
        self.feature_display_name = feature_display_name
        self.feature_name = feature_name
        self.last_reported_time = last_reported_time
        self.node_display_name = node_display_name
        self.node_id = node_id
        self.node_ip_addresses = node_ip_addresses
        self.node_resource_type = node_resource_type
        self.recommended_action = recommended_action
        self.reoccurrences_while_suppressed = reoccurrences_while_suppressed
        self.resolved_by = resolved_by
        self.resolved_time = resolved_time
        self.severity = severity
        self.status = status
        self.summary = summary
        self.suppress_duration = suppress_duration
        self.suppress_start_time = suppress_start_time
        self.suppressed_by = suppressed_by
        VapiStruct.__init__(self)


Alarm._set_binding_type(type.StructType(
    'com.vmware.nsx.model.alarm', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'alarm_source': type.OptionalType(type.ListType(type.StringType())),
        'alarm_source_type': type.OptionalType(type.StringType()),
        'entity_id': type.OptionalType(type.StringType()),
        'entity_resource_type': type.OptionalType(type.StringType()),
        'event_type': type.OptionalType(type.StringType()),
        'event_type_display_name': type.OptionalType(type.StringType()),
        'feature_display_name': type.OptionalType(type.StringType()),
        'feature_name': type.OptionalType(type.StringType()),
        'last_reported_time': type.OptionalType(type.IntegerType()),
        'node_display_name': type.OptionalType(type.StringType()),
        'node_id': type.OptionalType(type.StringType()),
        'node_ip_addresses': type.OptionalType(type.ListType(type.StringType())),
        'node_resource_type': type.OptionalType(type.StringType()),
        'recommended_action': type.OptionalType(type.StringType()),
        'reoccurrences_while_suppressed': type.OptionalType(type.IntegerType()),
        'resolved_by': type.OptionalType(type.StringType()),
        'resolved_time': type.OptionalType(type.IntegerType()),
        'severity': type.OptionalType(type.StringType()),
        'status': type.OptionalType(type.StringType()),
        'summary': type.OptionalType(type.StringType()),
        'suppress_duration': type.OptionalType(type.IntegerType()),
        'suppress_start_time': type.OptionalType(type.IntegerType()),
        'suppressed_by': type.OptionalType(type.StringType()),
    },
    Alarm,
    False,
    None))



class AlarmListResult(VapiStruct):
    """
    Alarm collection results

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`Alarm` or ``None``
        :param results: Alarm results
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


AlarmListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.alarm_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Alarm'))),
    },
    AlarmListResult,
    False,
    None))



class AlarmsListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`Alarm` or ``None``
        :param results: List of alarms known to the system
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


AlarmsListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.alarms_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Alarm'))),
    },
    AlarmsListResult,
    False,
    None))



class AllClusterGroupStatus(VapiStruct):
    """
    A list of the statuses of all the groups in the cluster.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    OVERALL_STATUS_STABLE = "STABLE"
    """


    """
    OVERALL_STATUS_DEGRADED = "DEGRADED"
    """


    """
    OVERALL_STATUS_UNAVAILABLE = "UNAVAILABLE"
    """


    """



    _canonical_to_pep_names = {
                            'cluster_id': 'cluster_id',
                            'groups': 'groups',
                            'overall_status': 'overall_status',
                            }

    def __init__(self,
                 cluster_id=None,
                 groups=None,
                 overall_status=None,
                ):
        """
        :type  cluster_id: :class:`str` or ``None``
        :param cluster_id: UUID of the cluster
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  groups: :class:`list` of :class:`ClusterGroupStatus` or ``None``
        :param groups: Array of groups and their statuses
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  overall_status: :class:`str` or ``None``
        :param overall_status: Possible values are: 
            
            * :attr:`AllClusterGroupStatus.OVERALL_STATUS_STABLE`
            * :attr:`AllClusterGroupStatus.OVERALL_STATUS_DEGRADED`
            * :attr:`AllClusterGroupStatus.OVERALL_STATUS_UNAVAILABLE`
            
             Overall status of the cluster
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.cluster_id = cluster_id
        self.groups = groups
        self.overall_status = overall_status
        VapiStruct.__init__(self)


AllClusterGroupStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.all_cluster_group_status', {
        'cluster_id': type.OptionalType(type.StringType()),
        'groups': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ClusterGroupStatus'))),
        'overall_status': type.OptionalType(type.StringType()),
    },
    AllClusterGroupStatus,
    False,
    None))



class AllocatedService(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    HIGH_AVAILABILITY_STATUS_ACTIVE = "ACTIVE"
    """


    """
    HIGH_AVAILABILITY_STATUS_STANDBY = "STANDBY"
    """


    """
    HIGH_AVAILABILITY_STATUS_DOWN = "DOWN"
    """


    """
    HIGH_AVAILABILITY_STATUS_SYNC = "SYNC"
    """


    """
    HIGH_AVAILABILITY_STATUS_UNKNOWN = "UNKNOWN"
    """


    """



    _canonical_to_pep_names = {
                            'allocation_details': 'allocation_details',
                            'high_availability_status': 'high_availability_status',
                            'service_reference': 'service_reference',
                            }

    def __init__(self,
                 allocation_details=None,
                 high_availability_status=None,
                 service_reference=None,
                ):
        """
        :type  allocation_details: :class:`list` of :class:`KeyValuePair` or ``None``
        :param allocation_details: Additional properties of a service, say the sub_pool_size and
            sub_pool_type for a LoadBalancer.
        :type  high_availability_status: :class:`str` or ``None``
        :param high_availability_status: Possible values are: 
            
            * :attr:`AllocatedService.HIGH_AVAILABILITY_STATUS_ACTIVE`
            * :attr:`AllocatedService.HIGH_AVAILABILITY_STATUS_STANDBY`
            * :attr:`AllocatedService.HIGH_AVAILABILITY_STATUS_DOWN`
            * :attr:`AllocatedService.HIGH_AVAILABILITY_STATUS_SYNC`
            * :attr:`AllocatedService.HIGH_AVAILABILITY_STATUS_UNKNOWN`
            
             Represents the active or the standby state of the service.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  service_reference: :class:`ResourceReference` or ``None``
        :param service_reference: Id and Name of the service context configured on edge node.
        """
        self.allocation_details = allocation_details
        self.high_availability_status = high_availability_status
        self.service_reference = service_reference
        VapiStruct.__init__(self)


AllocatedService._set_binding_type(type.StructType(
    'com.vmware.nsx.model.allocated_service', {
        'allocation_details': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'KeyValuePair'))),
        'high_availability_status': type.OptionalType(type.StringType()),
        'service_reference': type.OptionalType(type.ReferenceType(__name__, 'ResourceReference')),
    },
    AllocatedService,
    False,
    None))



class AllocationBasedOnFailureDomain(VapiStruct):
    """
    Auto place TIER1 logical routers, DHCP and MDProxy contexts on two edge
    nodes (active and standby) from different failure domains.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "AllocationBasedOnFailureDomain"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'enabled': 'enabled',
                            'action_type': 'action_type',
                            }

    def __init__(self,
                 enabled=None,
                 action_type='AllocationBasedOnFailureDomain',
                ):
        """
        :type  enabled: :class:`bool` or ``None``
        :param enabled: Enable placement algorithm to consider failure domain of edge
            transport nodes and place active and standby contexts in different
            failure domains.
        :type  action_type: :class:`str`
        :param action_type: Possible values are: 
            
            *
              :attr:`AllocationRuleAction.ACTION_TYPE_ALLOCATIONBASEDONFAILUREDOMAIN`
            
            Set action for each allocation rule on edge cluster which will help
            in auto placement.
        """
        self.enabled = enabled
        self._action_type = action_type
        VapiStruct.__init__(self)

    @property
    def action_type(self):
        """
        Return the discriminator value
        """
        return self._action_type

AllocationBasedOnFailureDomain._set_binding_type(type.StructType(
    'com.vmware.nsx.model.allocation_based_on_failure_domain', {
        'enabled': type.OptionalType(type.BooleanType()),
        'action_type': type.StringType(),
    },
    AllocationBasedOnFailureDomain,
    False,
    None))



class AllocationIpAddress(VapiStruct):
    """
    Allocation parameters for the IP address (e.g. specific IP address) can be
    specified. Tags, display_name and description attributes are not supported
    in this release.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'allocation_id': 'allocation_id',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 allocation_id=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  allocation_id: :class:`str` or ``None``
        :param allocation_id: Address that is allocated from pool format: ip
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.allocation_id = allocation_id
        VapiStruct.__init__(self)


AllocationIpAddress._set_binding_type(type.StructType(
    'com.vmware.nsx.model.allocation_ip_address', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'allocation_id': type.OptionalType(type.StringType()),
    },
    AllocationIpAddress,
    False,
    None))



class AllocationIpAddressListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`AllocationIpAddress` or ``None``
        :param results: Pool allocation list results
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


AllocationIpAddressListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.allocation_ip_address_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'AllocationIpAddress'))),
    },
    AllocationIpAddressListResult,
    False,
    None))



class AllocationPool(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'active_service_count': 'active_service_count',
                            'standby_service_count': 'standby_service_count',
                            'sub_pools': 'sub_pools',
                            }

    def __init__(self,
                 active_service_count=None,
                 standby_service_count=None,
                 sub_pools=None,
                ):
        """
        :type  active_service_count: :class:`long` or ``None``
        :param active_service_count: Represents the number of acitve services running on the edge node.
            format: int32
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  standby_service_count: :class:`long` or ``None``
        :param standby_service_count: Represents the number of standby services running on the edge node.
            format: int32
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sub_pools: :class:`list` of :class:`SubPool` or ``None``
        :param sub_pools: Allocation details of sub-pools configured on edge node.
        """
        self.active_service_count = active_service_count
        self.standby_service_count = standby_service_count
        self.sub_pools = sub_pools
        VapiStruct.__init__(self)


AllocationPool._set_binding_type(type.StructType(
    'com.vmware.nsx.model.allocation_pool', {
        'active_service_count': type.OptionalType(type.IntegerType()),
        'standby_service_count': type.OptionalType(type.IntegerType()),
        'sub_pools': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'SubPool'))),
    },
    AllocationPool,
    False,
    None))



class AllocationRule(VapiStruct):
    """
    Allocation rule on edge cluster which will be considered in auto placement
    of TIER1 logical routers, DHCP and MDProxy.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'action': 'action',
                            }

    def __init__(self,
                 action=None,
                ):
        """
        :type  action: :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param action: Set action for each allocation rule
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`AllocationRuleAction`. When methods return a value of this
            class as a return value, the attribute will contain all the
            attributes defined in :class:`AllocationRuleAction`.
        """
        self.action = action
        VapiStruct.__init__(self)


AllocationRule._set_binding_type(type.StructType(
    'com.vmware.nsx.model.allocation_rule', {
        'action': type.OptionalType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'AllocationRuleAction')])),
    },
    AllocationRule,
    False,
    None))



class AllocationRuleAction(VapiStruct):
    """
    Define action for each allocation rule which added on edge cluster.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "AllocationRuleAction"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    ACTION_TYPE_ALLOCATIONBASEDONFAILUREDOMAIN = "AllocationBasedOnFailureDomain"
    """


    """



    _canonical_to_pep_names = {
                            'action_type': 'action_type',
                            }

    def __init__(self,
                 action_type='AllocationRuleAction',
                ):
        """
        :type  action_type: :class:`str`
        :param action_type: Possible values are: 
            
            *
              :attr:`AllocationRuleAction.ACTION_TYPE_ALLOCATIONBASEDONFAILUREDOMAIN`
            
            Set action for each allocation rule on edge cluster which will help
            in auto placement.
        """
        self._action_type = action_type
        VapiStruct.__init__(self)

    @property
    def action_type(self):
        """
        Return the discriminator value
        """
        return self._action_type

AllocationRuleAction._set_binding_type(type.StructType(
    'com.vmware.nsx.model.allocation_rule_action', {
        'action_type': type.StringType(),
    },
    AllocationRuleAction,
    False,
    None))



class ApiError(VapiStruct):
    """
    Detailed information about an API Error

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'details': 'details',
                            'error_code': 'error_code',
                            'error_data': 'error_data',
                            'error_message': 'error_message',
                            'module_name': 'module_name',
                            'related_errors': 'related_errors',
                            }

    def __init__(self,
                 details=None,
                 error_code=None,
                 error_data=None,
                 error_message=None,
                 module_name=None,
                 related_errors=None,
                ):
        """
        :type  details: :class:`str` or ``None``
        :param details: Further details about the error
        :type  error_code: :class:`long` or ``None``
        :param error_code: A numeric error code format: int64
        :type  error_data: :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param error_data: Additional data about the error
        :type  error_message: :class:`str` or ``None``
        :param error_message: A description of the error
        :type  module_name: :class:`str` or ``None``
        :param module_name: The module name where the error occurred
        :type  related_errors: :class:`list` of :class:`RelatedApiError` or ``None``
        :param related_errors: Other errors related to this error
        """
        self.details = details
        self.error_code = error_code
        self.error_data = error_data
        self.error_message = error_message
        self.module_name = module_name
        self.related_errors = related_errors
        VapiStruct.__init__(self)


ApiError._set_binding_type(type.StructType(
    'com.vmware.nsx.model.api_error', {
        'details': type.OptionalType(type.StringType()),
        'error_code': type.OptionalType(type.IntegerType()),
        'error_data': type.OptionalType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct)),
        'error_message': type.OptionalType(type.StringType()),
        'module_name': type.OptionalType(type.StringType()),
        'related_errors': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'RelatedApiError'))),
    },
    ApiError,
    False,
    None))



class ApiServiceConfig(VapiStruct):
    """
    Properties that affect the configuration of the NSX API service.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'basic_authentication_enabled': 'basic_authentication_enabled',
                            'cipher_suites': 'cipher_suites',
                            'client_api_concurrency_limit': 'client_api_concurrency_limit',
                            'client_api_rate_limit': 'client_api_rate_limit',
                            'connection_timeout': 'connection_timeout',
                            'cookie_based_authentication_enabled': 'cookie_based_authentication_enabled',
                            'global_api_concurrency_limit': 'global_api_concurrency_limit',
                            'lockout_immune_addresses': 'lockout_immune_addresses',
                            'protocol_versions': 'protocol_versions',
                            'redirect_host': 'redirect_host',
                            'session_timeout': 'session_timeout',
                            }

    def __init__(self,
                 basic_authentication_enabled=None,
                 cipher_suites=None,
                 client_api_concurrency_limit=None,
                 client_api_rate_limit=None,
                 connection_timeout=None,
                 cookie_based_authentication_enabled=None,
                 global_api_concurrency_limit=None,
                 lockout_immune_addresses=None,
                 protocol_versions=None,
                 redirect_host=None,
                 session_timeout=None,
                ):
        """
        :type  basic_authentication_enabled: :class:`bool` or ``None``
        :param basic_authentication_enabled: Identifies whether basic authentication is enabled or disabled in
            API calls.
        :type  cipher_suites: :class:`list` of :class:`CipherSuite` or ``None``
        :param cipher_suites: The TLS cipher suites that the API service will negotiate.
        :type  client_api_concurrency_limit: :class:`long` or ``None``
        :param client_api_concurrency_limit: The maximum number of concurrent API requests that will be serviced
            for a given authenticated client. If the number of API requests
            being processed exceeds this limit, new API requests will be
            refused and a 503 Service Unavailable response will be returned to
            the client. To disable API concurrency limiting, set this value to
            0. format: int64
        :type  client_api_rate_limit: :class:`long` or ``None``
        :param client_api_rate_limit: The maximum number of API requests that will be serviced per second
            for a given authenticated client. If more API requests are received
            than can be serviced, a 429 Too Many Requests HTTP response will be
            returned. To disable API rate limiting, set this value to 0.
            format: int64
        :type  connection_timeout: :class:`long` or ``None``
        :param connection_timeout: NSX connection timeout, in seconds. To disable timeout, set to 0.
            format: int64
        :type  cookie_based_authentication_enabled: :class:`bool` or ``None``
        :param cookie_based_authentication_enabled: Identifies whether cookie-based authentication is enabled or
            disabled in API calls. When cookie-based authentication is
            disabled, new sessions cannot be created via /api/session/create.
        :type  global_api_concurrency_limit: :class:`long` or ``None``
        :param global_api_concurrency_limit: The maximum number of concurrent API requests that will be
            serviced. If the number of API requests being processed exceeds
            this limit, new API requests will be refused and a 503 Service
            Unavailable response will be returned to the client. To disable API
            concurrency limiting, set this value to 0. format: int64
        :type  lockout_immune_addresses: :class:`list` of :class:`str` or ``None``
        :param lockout_immune_addresses: The list of IP addresses which are not subjected to a lockout on
            failed login attempts. format: ip
        :type  protocol_versions: :class:`list` of :class:`ProtocolVersion` or ``None``
        :param protocol_versions: The TLS protocol versions that the API service will negotiate.
        :type  redirect_host: :class:`str` or ``None``
        :param redirect_host: Host name or IP address to use for redirect location headers, or
            empty string to derive from current request. To disable, set
            redirect_host to the empty string (\"\").
        :type  session_timeout: :class:`long` or ``None``
        :param session_timeout: NSX session inactivity timeout format: int64
        """
        self.basic_authentication_enabled = basic_authentication_enabled
        self.cipher_suites = cipher_suites
        self.client_api_concurrency_limit = client_api_concurrency_limit
        self.client_api_rate_limit = client_api_rate_limit
        self.connection_timeout = connection_timeout
        self.cookie_based_authentication_enabled = cookie_based_authentication_enabled
        self.global_api_concurrency_limit = global_api_concurrency_limit
        self.lockout_immune_addresses = lockout_immune_addresses
        self.protocol_versions = protocol_versions
        self.redirect_host = redirect_host
        self.session_timeout = session_timeout
        VapiStruct.__init__(self)


ApiServiceConfig._set_binding_type(type.StructType(
    'com.vmware.nsx.model.api_service_config', {
        'basic_authentication_enabled': type.OptionalType(type.BooleanType()),
        'cipher_suites': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'CipherSuite'))),
        'client_api_concurrency_limit': type.OptionalType(type.IntegerType()),
        'client_api_rate_limit': type.OptionalType(type.IntegerType()),
        'connection_timeout': type.OptionalType(type.IntegerType()),
        'cookie_based_authentication_enabled': type.OptionalType(type.BooleanType()),
        'global_api_concurrency_limit': type.OptionalType(type.IntegerType()),
        'lockout_immune_addresses': type.OptionalType(type.ListType(type.StringType())),
        'protocol_versions': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ProtocolVersion'))),
        'redirect_host': type.OptionalType(type.StringType()),
        'session_timeout': type.OptionalType(type.IntegerType()),
    },
    ApiServiceConfig,
    False,
    None))



class ApplianceManagementTaskListResult(VapiStruct):
    """
    Appliance management task query results

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`ApplianceManagementTaskProperties` or ``None``
        :param results: Task property results
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


ApplianceManagementTaskListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.appliance_management_task_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ApplianceManagementTaskProperties'))),
    },
    ApplianceManagementTaskListResult,
    False,
    None))



class ApplianceManagementTaskProperties(VapiStruct):
    """
    Appliance management task properties

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATUS_RUNNING = "running"
    """


    """
    STATUS_ERROR = "error"
    """


    """
    STATUS_SUCCESS = "success"
    """


    """
    STATUS_CANCELING = "canceling"
    """


    """
    STATUS_CANCELED = "canceled"
    """


    """
    STATUS_KILLED = "killed"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'async_response_available': 'async_response_available',
                            'cancelable': 'cancelable',
                            'description': 'description',
                            'details': 'details',
                            'end_time': 'end_time',
                            'id': 'id',
                            'message': 'message',
                            'progress': 'progress',
                            'request_method': 'request_method',
                            'request_uri': 'request_uri',
                            'start_time': 'start_time',
                            'status': 'status',
                            'user': 'user',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 async_response_available=None,
                 cancelable=None,
                 description=None,
                 details=None,
                 end_time=None,
                 id=None,
                 message=None,
                 progress=None,
                 request_method=None,
                 request_uri=None,
                 start_time=None,
                 status=None,
                 user=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  async_response_available: :class:`bool` or ``None``
        :param async_response_available: True if response for asynchronous request is available
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  cancelable: :class:`bool` or ``None``
        :param cancelable: True if this task can be canceled
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of the task
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  details: :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param details: Details about the task if known
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  end_time: :class:`long` or ``None``
        :param end_time: The end time of the task in epoch milliseconds format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  id: :class:`str` or ``None``
        :param id: Identifier for this task
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  message: :class:`str` or ``None``
        :param message: A message describing the disposition of the task
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  progress: :class:`long` or ``None``
        :param progress: Task progress if known, from 0 to 100 format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  request_method: :class:`str` or ``None``
        :param request_method: HTTP request method
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  request_uri: :class:`str` or ``None``
        :param request_uri: URI of the method invocation that spawned this task
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  start_time: :class:`long` or ``None``
        :param start_time: The start time of the task in epoch milliseconds format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  status: :class:`str` or ``None``
        :param status: Possible values are: 
            
            * :attr:`ApplianceManagementTaskProperties.STATUS_RUNNING`
            * :attr:`ApplianceManagementTaskProperties.STATUS_ERROR`
            * :attr:`ApplianceManagementTaskProperties.STATUS_SUCCESS`
            * :attr:`ApplianceManagementTaskProperties.STATUS_CANCELING`
            * :attr:`ApplianceManagementTaskProperties.STATUS_CANCELED`
            * :attr:`ApplianceManagementTaskProperties.STATUS_KILLED`
            
             Current status of the task
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  user: :class:`str` or ``None``
        :param user: Name of the user who created this task
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.async_response_available = async_response_available
        self.cancelable = cancelable
        self.description = description
        self.details = details
        self.end_time = end_time
        self.id = id
        self.message = message
        self.progress = progress
        self.request_method = request_method
        self.request_uri = request_uri
        self.start_time = start_time
        self.status = status
        self.user = user
        VapiStruct.__init__(self)


ApplianceManagementTaskProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.appliance_management_task_properties', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'async_response_available': type.OptionalType(type.BooleanType()),
        'cancelable': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'details': type.OptionalType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct)),
        'end_time': type.OptionalType(type.IntegerType()),
        'id': type.OptionalType(type.StringType()),
        'message': type.OptionalType(type.StringType()),
        'progress': type.OptionalType(type.IntegerType()),
        'request_method': type.OptionalType(type.StringType()),
        'request_uri': type.OptionalType(type.StringType()),
        'start_time': type.OptionalType(type.IntegerType()),
        'status': type.OptionalType(type.StringType()),
        'user': type.OptionalType(type.StringType()),
    },
    ApplianceManagementTaskProperties,
    False,
    None))



class AppliedTos(VapiStruct):
    """
    Entity lists where the profile will be enabled on.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'logical_ports': 'logical_ports',
                            'logical_switches': 'logical_switches',
                            'nsgroups': 'nsgroups',
                            }

    def __init__(self,
                 logical_ports=None,
                 logical_switches=None,
                 nsgroups=None,
                ):
        """
        :type  logical_ports: :class:`list` of :class:`ResourceReference` or ``None``
        :param logical_ports: Logical Port List
        :type  logical_switches: :class:`list` of :class:`ResourceReference` or ``None``
        :param logical_switches: Logical Switch List
        :type  nsgroups: :class:`list` of :class:`ResourceReference` or ``None``
        :param nsgroups: NSGroup List
        """
        self.logical_ports = logical_ports
        self.logical_switches = logical_switches
        self.nsgroups = nsgroups
        VapiStruct.__init__(self)


AppliedTos._set_binding_type(type.StructType(
    'com.vmware.nsx.model.applied_tos', {
        'logical_ports': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceReference'))),
        'logical_switches': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceReference'))),
        'nsgroups': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceReference'))),
    },
    AppliedTos,
    False,
    None))



class ArpHeader(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    OP_CODE_REQUEST = "ARP_REQUEST"
    """


    """
    OP_CODE_REPLY = "ARP_REPLY"
    """


    """



    _canonical_to_pep_names = {
                            'dst_ip': 'dst_ip',
                            'op_code': 'op_code',
                            'src_ip': 'src_ip',
                            }

    def __init__(self,
                 dst_ip=None,
                 op_code=None,
                 src_ip=None,
                ):
        """
        :type  dst_ip: :class:`str` or ``None``
        :param dst_ip: The destination IP address format: ipv4
        :type  op_code: :class:`str` or ``None``
        :param op_code: Possible values are: 
            
            * :attr:`ArpHeader.OP_CODE_REQUEST`
            * :attr:`ArpHeader.OP_CODE_REPLY`
            
             This field specifies the nature of the Arp message being sent.
        :type  src_ip: :class:`str` or ``None``
        :param src_ip: This field specifies the IP address of the sender. If omitted, the
            src_ip is set to 0.0.0.0. format: ipv4
        """
        self.dst_ip = dst_ip
        self.op_code = op_code
        self.src_ip = src_ip
        VapiStruct.__init__(self)


ArpHeader._set_binding_type(type.StructType(
    'com.vmware.nsx.model.arp_header', {
        'dst_ip': type.OptionalType(type.StringType()),
        'op_code': type.OptionalType(type.StringType()),
        'src_ip': type.OptionalType(type.StringType()),
    },
    ArpHeader,
    False,
    None))



class AssignedByDhcp(VapiStruct):
    """
    This type can be specified in ip assignment spec of host switch if DHCP
    based IP assignment is desired for host switch virtual tunnel endpoints.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "AssignedByDhcp"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'resource_type': 'resource_type',
                            }

    def __init__(self,
                 resource_type='AssignedByDhcp',
                ):
        """
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`IpAssignmentSpec.RESOURCE_TYPE_STATICIPPOOLSPEC`
            * :attr:`IpAssignmentSpec.RESOURCE_TYPE_STATICIPLISTSPEC`
            * :attr:`IpAssignmentSpec.RESOURCE_TYPE_ASSIGNEDBYDHCP`
            * :attr:`IpAssignmentSpec.RESOURCE_TYPE_STATICIPMACLISTSPEC`
        """
        self._resource_type = resource_type
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

AssignedByDhcp._set_binding_type(type.StructType(
    'com.vmware.nsx.model.assigned_by_dhcp', {
        'resource_type': type.StringType(),
    },
    AssignedByDhcp,
    False,
    None))



class AssociationListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`ResourceReference` or ``None``
        :param results: Paged Collection of ResourceReference
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


AssociationListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.association_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceReference'))),
    },
    AssociationListResult,
    False,
    None))



class AttachmentContext(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "AttachmentContext"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    ALLOCATE_ADDRESSES_IPPOOL = "IpPool"
    """


    """
    ALLOCATE_ADDRESSES_MACPOOL = "MacPool"
    """


    """
    ALLOCATE_ADDRESSES_BOTH = "Both"
    """


    """
    ALLOCATE_ADDRESSES_NONE = "None"
    """


    """



    _canonical_to_pep_names = {
                            'allocate_addresses': 'allocate_addresses',
                            'resource_type': 'resource_type',
                            }

    def __init__(self,
                 allocate_addresses=None,
                 resource_type='AttachmentContext',
                ):
        """
        :type  allocate_addresses: :class:`str` or ``None``
        :param allocate_addresses: Possible values are: 
            
            * :attr:`AttachmentContext.ALLOCATE_ADDRESSES_IPPOOL`
            * :attr:`AttachmentContext.ALLOCATE_ADDRESSES_MACPOOL`
            * :attr:`AttachmentContext.ALLOCATE_ADDRESSES_BOTH`
            * :attr:`AttachmentContext.ALLOCATE_ADDRESSES_NONE`
            
            A flag to indicate whether to allocate addresses from allocation
            pools bound to the parent logical switch.
        :type  resource_type: :class:`str`
        :param resource_type: Used to identify which concrete class it is
        """
        self.allocate_addresses = allocate_addresses
        self._resource_type = resource_type
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

AttachmentContext._set_binding_type(type.StructType(
    'com.vmware.nsx.model.attachment_context', {
        'allocate_addresses': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
    },
    AttachmentContext,
    False,
    None))



class Attribute(VapiStruct):
    """
    Attribute specific to a partner. There attributes are passed on to the
    partner appliance and is opaque to the NSX Manager. The Attributes used by
    the partner applicance.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    ATTRIBUTE_TYPE_IP_ADDRESS = "IP_ADDRESS"
    """


    """
    ATTRIBUTE_TYPE_PORT = "PORT"
    """


    """
    ATTRIBUTE_TYPE_PASSWORD = "PASSWORD"
    """


    """
    ATTRIBUTE_TYPE_STRING = "STRING"
    """


    """
    ATTRIBUTE_TYPE_LONG = "LONG"
    """


    """
    ATTRIBUTE_TYPE_BOOLEAN = "BOOLEAN"
    """


    """



    _canonical_to_pep_names = {
                            'attribute_type': 'attribute_type',
                            'display_name': 'display_name',
                            'key': 'key',
                            'read_only': 'read_only',
                            'value': 'value',
                            }

    def __init__(self,
                 attribute_type=None,
                 display_name=None,
                 key=None,
                 read_only=None,
                 value=None,
                ):
        """
        :type  attribute_type: :class:`str` or ``None``
        :param attribute_type: Possible values are: 
            
            * :attr:`Attribute.ATTRIBUTE_TYPE_IP_ADDRESS`
            * :attr:`Attribute.ATTRIBUTE_TYPE_PORT`
            * :attr:`Attribute.ATTRIBUTE_TYPE_PASSWORD`
            * :attr:`Attribute.ATTRIBUTE_TYPE_STRING`
            * :attr:`Attribute.ATTRIBUTE_TYPE_LONG`
            * :attr:`Attribute.ATTRIBUTE_TYPE_BOOLEAN`
            
             Attribute Type can be of any of the allowed enum type.
        :type  display_name: :class:`str` or ``None``
        :param display_name: Attribute display name string value.
        :type  key: :class:`str` or ``None``
        :param key: Attribute key string value.
        :type  read_only: :class:`bool` or ``None``
        :param read_only: Read only Attribute cannot be overdidden by service
            instance/deployment.
        :type  value: :class:`str` or ``None``
        :param value: Attribute value string value.
        """
        self.attribute_type = attribute_type
        self.display_name = display_name
        self.key = key
        self.read_only = read_only
        self.value = value
        VapiStruct.__init__(self)


Attribute._set_binding_type(type.StructType(
    'com.vmware.nsx.model.attribute', {
        'attribute_type': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'key': type.OptionalType(type.StringType()),
        'read_only': type.OptionalType(type.BooleanType()),
        'value': type.OptionalType(type.StringType()),
    },
    Attribute,
    False,
    None))



class AuditLog(VapiStruct):
    """
    Audit log in RFC5424 format

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'appname': 'appname',
                            'facility': 'facility',
                            'full_log': 'full_log',
                            'hostname': 'hostname',
                            'message': 'message',
                            'msgid': 'msgid',
                            'priority': 'priority',
                            'procid': 'procid',
                            'struct_data': 'struct_data',
                            'timestamp': 'timestamp',
                            }

    def __init__(self,
                 appname=None,
                 facility=None,
                 full_log=None,
                 hostname=None,
                 message=None,
                 msgid=None,
                 priority=None,
                 procid=None,
                 struct_data=None,
                 timestamp=None,
                ):
        """
        :type  appname: :class:`str` or ``None``
        :param appname: Application name field of the log
        :type  facility: :class:`long` or ``None``
        :param facility: Facility field of the log format: int64
        :type  full_log: :class:`str` or ``None``
        :param full_log: Full log with both header and message
        :type  hostname: :class:`str` or ``None``
        :param hostname: Hostname field of the log
        :type  message: :class:`str` or ``None``
        :param message: Message field of the log
        :type  msgid: :class:`str` or ``None``
        :param msgid: Message ID field of the log
        :type  priority: :class:`long` or ``None``
        :param priority: Priority field of the log format: int64
        :type  procid: :class:`long` or ``None``
        :param procid: Process ID field of the log format: int64
        :type  struct_data: :class:`StructuredData` or ``None``
        :param struct_data: Structured data field of the log
        :type  timestamp: :class:`str` or ``None``
        :param timestamp: Date and time in UTC of the log
        """
        self.appname = appname
        self.facility = facility
        self.full_log = full_log
        self.hostname = hostname
        self.message = message
        self.msgid = msgid
        self.priority = priority
        self.procid = procid
        self.struct_data = struct_data
        self.timestamp = timestamp
        VapiStruct.__init__(self)


AuditLog._set_binding_type(type.StructType(
    'com.vmware.nsx.model.audit_log', {
        'appname': type.OptionalType(type.StringType()),
        'facility': type.OptionalType(type.IntegerType()),
        'full_log': type.OptionalType(type.StringType()),
        'hostname': type.OptionalType(type.StringType()),
        'message': type.OptionalType(type.StringType()),
        'msgid': type.OptionalType(type.StringType()),
        'priority': type.OptionalType(type.IntegerType()),
        'procid': type.OptionalType(type.IntegerType()),
        'struct_data': type.OptionalType(type.ReferenceType(__name__, 'StructuredData')),
        'timestamp': type.OptionalType(type.StringType()),
    },
    AuditLog,
    False,
    None))



class AuditLogListResult(VapiStruct):
    """
    Audit log collection results

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'last_full_sync_timestamp': 'last_full_sync_timestamp',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 last_full_sync_timestamp=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_full_sync_timestamp: :class:`str` or ``None``
        :param last_full_sync_timestamp: Timestamp of the last full audit log collection
        :type  results: :class:`list` of :class:`AuditLog` or ``None``
        :param results: Audit log results
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.last_full_sync_timestamp = last_full_sync_timestamp
        self.results = results
        VapiStruct.__init__(self)


AuditLogListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.audit_log_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'last_full_sync_timestamp': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'AuditLog'))),
    },
    AuditLogListResult,
    False,
    None))



class AuditLogRequest(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    LOG_FILTER_TYPE_TEXT = "TEXT"
    """


    """
    LOG_FILTER_TYPE_REGEX = "REGEX"
    """


    """



    _canonical_to_pep_names = {
                            'log_age_limit': 'log_age_limit',
                            'log_filter': 'log_filter',
                            'log_filter_type': 'log_filter_type',
                            }

    def __init__(self,
                 log_age_limit=None,
                 log_filter=None,
                 log_filter_type=None,
                ):
        """
        :type  log_age_limit: :class:`long` or ``None``
        :param log_age_limit: Include logs with timstamps not past the age limit in days format:
            int64
        :type  log_filter: :class:`str` or ``None``
        :param log_filter: Audit logs should meet the filter condition
        :type  log_filter_type: :class:`str` or ``None``
        :param log_filter_type: Possible values are: 
            
            * :attr:`AuditLogRequest.LOG_FILTER_TYPE_TEXT`
            * :attr:`AuditLogRequest.LOG_FILTER_TYPE_REGEX`
            
             Type of log filter
        """
        self.log_age_limit = log_age_limit
        self.log_filter = log_filter
        self.log_filter_type = log_filter_type
        VapiStruct.__init__(self)


AuditLogRequest._set_binding_type(type.StructType(
    'com.vmware.nsx.model.audit_log_request', {
        'log_age_limit': type.OptionalType(type.IntegerType()),
        'log_filter': type.OptionalType(type.StringType()),
        'log_filter_type': type.OptionalType(type.StringType()),
    },
    AuditLogRequest,
    False,
    None))



class AuthenticationPolicyProperties(VapiStruct):
    """
    Configuration of authentication policies for the NSX node

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'api_failed_auth_lockout_period': 'api_failed_auth_lockout_period',
                            'api_failed_auth_reset_period': 'api_failed_auth_reset_period',
                            'api_max_auth_failures': 'api_max_auth_failures',
                            'cli_failed_auth_lockout_period': 'cli_failed_auth_lockout_period',
                            'cli_max_auth_failures': 'cli_max_auth_failures',
                            'minimum_password_length': 'minimum_password_length',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 api_failed_auth_lockout_period=None,
                 api_failed_auth_reset_period=None,
                 api_max_auth_failures=None,
                 cli_failed_auth_lockout_period=None,
                 cli_max_auth_failures=None,
                 minimum_password_length=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  api_failed_auth_lockout_period: :class:`long` or ``None``
        :param api_failed_auth_lockout_period: Once a lockout occurs, the account remains locked out of the API
            for this time period. Only applies to NSX Manager nodes. Ignored on
            other node types. format: int64
        :type  api_failed_auth_reset_period: :class:`long` or ``None``
        :param api_failed_auth_reset_period: In order to trigger an account lockout, all authentication failures
            must occur in this time window. If the reset period expires, the
            failed login count is reset to zero. Only applies to NSX Manager
            nodes. Ignored on other node types. format: int64
        :type  api_max_auth_failures: :class:`long` or ``None``
        :param api_max_auth_failures: Only applies to NSX Manager nodes. Ignored on other node types.
            format: int64
        :type  cli_failed_auth_lockout_period: :class:`long` or ``None``
        :param cli_failed_auth_lockout_period: Once a lockout occurs, the account remains locked out of the CLI
            for this time period. While the lockout period is in effect,
            additional authentication attempts restart the lockout period, even
            if a valid password is specified. format: int64
        :type  cli_max_auth_failures: :class:`long` or ``None``
        :param cli_max_auth_failures: Number of authentication failures that trigger CLI lockout format:
            int64
        :type  minimum_password_length: :class:`long` or ``None``
        :param minimum_password_length: Minimum number of characters required in account passwords format:
            int64
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.api_failed_auth_lockout_period = api_failed_auth_lockout_period
        self.api_failed_auth_reset_period = api_failed_auth_reset_period
        self.api_max_auth_failures = api_max_auth_failures
        self.cli_failed_auth_lockout_period = cli_failed_auth_lockout_period
        self.cli_max_auth_failures = cli_max_auth_failures
        self.minimum_password_length = minimum_password_length
        VapiStruct.__init__(self)


AuthenticationPolicyProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.authentication_policy_properties', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'api_failed_auth_lockout_period': type.OptionalType(type.IntegerType()),
        'api_failed_auth_reset_period': type.OptionalType(type.IntegerType()),
        'api_max_auth_failures': type.OptionalType(type.IntegerType()),
        'cli_failed_auth_lockout_period': type.OptionalType(type.IntegerType()),
        'cli_max_auth_failures': type.OptionalType(type.IntegerType()),
        'minimum_password_length': type.OptionalType(type.IntegerType()),
    },
    AuthenticationPolicyProperties,
    False,
    None))



class AuthenticationScheme(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'scheme_name': 'scheme_name',
                            }

    def __init__(self,
                 scheme_name=None,
                ):
        """
        :type  scheme_name: :class:`str` or ``None``
        :param scheme_name: Authentication scheme name
        """
        self.scheme_name = scheme_name
        VapiStruct.__init__(self)


AuthenticationScheme._set_binding_type(type.StructType(
    'com.vmware.nsx.model.authentication_scheme', {
        'scheme_name': type.OptionalType(type.StringType()),
    },
    AuthenticationScheme,
    False,
    None))



class AutomaticHealthCheck(VapiStruct):
    """
    Health check performed by system automatically on a specific transport
    zone. For overlay based zone, health check is performed on corresponding
    N-VDS of each transport node with the VLAN and MTU specified by uplink
    profile of N-VDS for the node. For VLAN based zone, health check is
    performed on corresponding N-VDS of each transport node with MTU specified
    by uplink profile of N-VDS for the node and VLAN specified by all logical
    switches in this zone.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'result': 'result',
                            'transport_zone_id': 'transport_zone_id',
                            }

    def __init__(self,
                 result=None,
                 transport_zone_id=None,
                ):
        """
        :type  result: :class:`HealthCheckResult` or ``None``
        :param result: 
        :type  transport_zone_id: :class:`str` or ``None``
        :param transport_zone_id: ID of the transport zone where this automatic health check is
            performed.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.result = result
        self.transport_zone_id = transport_zone_id
        VapiStruct.__init__(self)


AutomaticHealthCheck._set_binding_type(type.StructType(
    'com.vmware.nsx.model.automatic_health_check', {
        'result': type.OptionalType(type.ReferenceType(__name__, 'HealthCheckResult')),
        'transport_zone_id': type.OptionalType(type.StringType()),
    },
    AutomaticHealthCheck,
    False,
    None))



class AutomaticHealthCheckListResult(VapiStruct):
    """
    Automatic health check list result for query with list parameters.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`AutomaticHealthCheck` or ``None``
        :param results: Automatic Health Check List
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


AutomaticHealthCheckListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.automatic_health_check_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'AutomaticHealthCheck'))),
    },
    AutomaticHealthCheckListResult,
    False,
    None))



class AutomaticHealthCheckToggle(VapiStruct):
    """
    Toggle to enable/disable automatic health check.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'enabled': 'enabled',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 enabled=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  enabled: :class:`bool` or ``None``
        :param enabled: Status of automatic health check
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.enabled = enabled
        VapiStruct.__init__(self)


AutomaticHealthCheckToggle._set_binding_type(type.StructType(
    'com.vmware.nsx.model.automatic_health_check_toggle', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'enabled': type.OptionalType(type.BooleanType()),
    },
    AutomaticHealthCheckToggle,
    False,
    None))



class Axes(VapiStruct):
    """
    Represents X and Y axes of a graph. For a multi-graph, the same axes are
    shared by all the graphs.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'x_label': 'x_label',
                            'y_label': 'y_label',
                            }

    def __init__(self,
                 x_label=None,
                 y_label=None,
                ):
        """
        :type  x_label: :class:`Label` or ``None``
        :param x_label: Label for X axis of a graph
        :type  y_label: :class:`Label` or ``None``
        :param y_label: Label for Y axis of a graph
        """
        self.x_label = x_label
        self.y_label = y_label
        VapiStruct.__init__(self)


Axes._set_binding_type(type.StructType(
    'com.vmware.nsx.model.axes', {
        'x_label': type.OptionalType(type.ReferenceType(__name__, 'Label')),
        'y_label': type.OptionalType(type.ReferenceType(__name__, 'Label')),
    },
    Axes,
    False,
    None))



class BFDDiagnosticCount(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'administratively_down_count': 'administratively_down_count',
                            'concatenated_path_down_count': 'concatenated_path_down_count',
                            'control_detection_time_expired_count': 'control_detection_time_expired_count',
                            'echo_function_failed_count': 'echo_function_failed_count',
                            'forwarding_plane_reset_count': 'forwarding_plane_reset_count',
                            'neighbor_signaled_session_down_count': 'neighbor_signaled_session_down_count',
                            'no_diagnostic_count': 'no_diagnostic_count',
                            'path_down_count': 'path_down_count',
                            'reverse_concatenated_path_down_count': 'reverse_concatenated_path_down_count',
                            }

    def __init__(self,
                 administratively_down_count=None,
                 concatenated_path_down_count=None,
                 control_detection_time_expired_count=None,
                 echo_function_failed_count=None,
                 forwarding_plane_reset_count=None,
                 neighbor_signaled_session_down_count=None,
                 no_diagnostic_count=None,
                 path_down_count=None,
                 reverse_concatenated_path_down_count=None,
                ):
        """
        :type  administratively_down_count: :class:`long` or ``None``
        :param administratively_down_count: Number of tunnels with administratively down diagnostic message
            format: int64
        :type  concatenated_path_down_count: :class:`long` or ``None``
        :param concatenated_path_down_count: Number of tunnels with concatenated path down diagnostic message
            format: int64
        :type  control_detection_time_expired_count: :class:`long` or ``None``
        :param control_detection_time_expired_count: Number of tunnels with control detection time expired diagnostic
            message format: int64
        :type  echo_function_failed_count: :class:`long` or ``None``
        :param echo_function_failed_count: Number of tunnels with echo function failed diagnostic message
            format: int64
        :type  forwarding_plane_reset_count: :class:`long` or ``None``
        :param forwarding_plane_reset_count: Number of tunnels with forwarding plane reset diagnostic message
            format: int64
        :type  neighbor_signaled_session_down_count: :class:`long` or ``None``
        :param neighbor_signaled_session_down_count: Number of tunnels neighbor signaled session down format: int64
        :type  no_diagnostic_count: :class:`long` or ``None``
        :param no_diagnostic_count: Number of tunnels with no diagnostic format: int64
        :type  path_down_count: :class:`long` or ``None``
        :param path_down_count: Number of tunnels with path down diagnostic message format: int64
        :type  reverse_concatenated_path_down_count: :class:`long` or ``None``
        :param reverse_concatenated_path_down_count: Number of tunnels with reverse concatenated path down diagnostic
            message format: int64
        """
        self.administratively_down_count = administratively_down_count
        self.concatenated_path_down_count = concatenated_path_down_count
        self.control_detection_time_expired_count = control_detection_time_expired_count
        self.echo_function_failed_count = echo_function_failed_count
        self.forwarding_plane_reset_count = forwarding_plane_reset_count
        self.neighbor_signaled_session_down_count = neighbor_signaled_session_down_count
        self.no_diagnostic_count = no_diagnostic_count
        self.path_down_count = path_down_count
        self.reverse_concatenated_path_down_count = reverse_concatenated_path_down_count
        VapiStruct.__init__(self)


BFDDiagnosticCount._set_binding_type(type.StructType(
    'com.vmware.nsx.model.BFD_diagnostic_count', {
        'administratively_down_count': type.OptionalType(type.IntegerType()),
        'concatenated_path_down_count': type.OptionalType(type.IntegerType()),
        'control_detection_time_expired_count': type.OptionalType(type.IntegerType()),
        'echo_function_failed_count': type.OptionalType(type.IntegerType()),
        'forwarding_plane_reset_count': type.OptionalType(type.IntegerType()),
        'neighbor_signaled_session_down_count': type.OptionalType(type.IntegerType()),
        'no_diagnostic_count': type.OptionalType(type.IntegerType()),
        'path_down_count': type.OptionalType(type.IntegerType()),
        'reverse_concatenated_path_down_count': type.OptionalType(type.IntegerType()),
    },
    BFDDiagnosticCount,
    False,
    None))



class BFDProperties(VapiStruct):
    """
    BFD information

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    REMOTE_STATE_UNKNOWN_STATE = "UNKNOWN_STATE"
    """


    """
    REMOTE_STATE_ADMIN_DOWN = "ADMIN_DOWN"
    """


    """
    REMOTE_STATE_DOWN = "DOWN"
    """


    """
    REMOTE_STATE_INIT = "INIT"
    """


    """
    REMOTE_STATE_UP = "UP"
    """


    """
    STATE_UNKNOWN_STATE = "UNKNOWN_STATE"
    """


    """
    STATE_ADMIN_DOWN = "ADMIN_DOWN"
    """


    """
    STATE_DOWN = "DOWN"
    """


    """
    STATE_INIT = "INIT"
    """


    """
    STATE_UP = "UP"
    """


    """



    _canonical_to_pep_names = {
                            'active': 'active',
                            'diagnostic': 'diagnostic',
                            'forwarding': 'forwarding',
                            'remote_diagnostic': 'remote_diagnostic',
                            'remote_state': 'remote_state',
                            'state': 'state',
                            }

    def __init__(self,
                 active=None,
                 diagnostic=None,
                 forwarding=None,
                 remote_diagnostic=None,
                 remote_state=None,
                 state=None,
                ):
        """
        :type  active: :class:`bool` or ``None``
        :param active: True if tunnel is active in a gateway HA setup
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  diagnostic: :class:`str` or ``None``
        :param diagnostic: A short message indicating what the BFD session thinks is wrong in
            case of a problem
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  forwarding: :class:`bool` or ``None``
        :param forwarding: True if the BFD session believes this interface may be used to
            forward traffic
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  remote_diagnostic: :class:`str` or ``None``
        :param remote_diagnostic: A short message indicating what the remote interface's BFD session
            thinks is wrong in case of a problem
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  remote_state: :class:`str` or ``None``
        :param remote_state: Possible values are: 
            
            * :attr:`BFDProperties.REMOTE_STATE_UNKNOWN_STATE`
            * :attr:`BFDProperties.REMOTE_STATE_ADMIN_DOWN`
            * :attr:`BFDProperties.REMOTE_STATE_DOWN`
            * :attr:`BFDProperties.REMOTE_STATE_INIT`
            * :attr:`BFDProperties.REMOTE_STATE_UP`
            
             State of the remote interface's BFD session
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  state: :class:`str` or ``None``
        :param state: Possible values are: 
            
            * :attr:`BFDProperties.STATE_UNKNOWN_STATE`
            * :attr:`BFDProperties.STATE_ADMIN_DOWN`
            * :attr:`BFDProperties.STATE_DOWN`
            * :attr:`BFDProperties.STATE_INIT`
            * :attr:`BFDProperties.STATE_UP`
            
             State of the BFD session
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.active = active
        self.diagnostic = diagnostic
        self.forwarding = forwarding
        self.remote_diagnostic = remote_diagnostic
        self.remote_state = remote_state
        self.state = state
        VapiStruct.__init__(self)


BFDProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.BFD_properties', {
        'active': type.OptionalType(type.BooleanType()),
        'diagnostic': type.OptionalType(type.StringType()),
        'forwarding': type.OptionalType(type.BooleanType()),
        'remote_diagnostic': type.OptionalType(type.StringType()),
        'remote_state': type.OptionalType(type.StringType()),
        'state': type.OptionalType(type.StringType()),
    },
    BFDProperties,
    False,
    None))



class BFDStatusCount(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'bfd_admin_down_count': 'bfd_admin_down_count',
                            'bfd_down_count': 'bfd_down_count',
                            'bfd_init_count': 'bfd_init_count',
                            'bfd_up_count': 'bfd_up_count',
                            }

    def __init__(self,
                 bfd_admin_down_count=None,
                 bfd_down_count=None,
                 bfd_init_count=None,
                 bfd_up_count=None,
                ):
        """
        :type  bfd_admin_down_count: :class:`long` or ``None``
        :param bfd_admin_down_count: Number of tunnels in BFD admin down state format: int32
        :type  bfd_down_count: :class:`long` or ``None``
        :param bfd_down_count: Number of tunnels in BFD down state format: int32
        :type  bfd_init_count: :class:`long` or ``None``
        :param bfd_init_count: Number of tunnels in BFD init state format: int32
        :type  bfd_up_count: :class:`long` or ``None``
        :param bfd_up_count: Number of tunnels in BFD up state format: int32
        """
        self.bfd_admin_down_count = bfd_admin_down_count
        self.bfd_down_count = bfd_down_count
        self.bfd_init_count = bfd_init_count
        self.bfd_up_count = bfd_up_count
        VapiStruct.__init__(self)


BFDStatusCount._set_binding_type(type.StructType(
    'com.vmware.nsx.model.BFD_status_count', {
        'bfd_admin_down_count': type.OptionalType(type.IntegerType()),
        'bfd_down_count': type.OptionalType(type.IntegerType()),
        'bfd_init_count': type.OptionalType(type.IntegerType()),
        'bfd_up_count': type.OptionalType(type.IntegerType()),
    },
    BFDStatusCount,
    False,
    None))



class BGPCommunityList(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    COMMUNITY_TYPE_NORMALBGPCOMMUNITY = "NormalBGPCommunity"
    """


    """
    COMMUNITY_TYPE_LARGEBGPCOMMUNITY = "LargeBGPCommunity"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'communities': 'communities',
                            'community_type': 'community_type',
                            'logical_router_id': 'logical_router_id',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 communities=None,
                 community_type=None,
                 logical_router_id=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  communities: :class:`list` of :class:`str` or ``None``
        :param communities: Array of BGP communities
        :type  community_type: :class:`str` or ``None``
        :param community_type: Possible values are: 
            
            * :attr:`BGPCommunityList.COMMUNITY_TYPE_NORMALBGPCOMMUNITY`
            * :attr:`BGPCommunityList.COMMUNITY_TYPE_LARGEBGPCOMMUNITY`
            
            BGP community type. It has two types as NormalBGPCommunity BGP
            normal community which includes well-known community name as well
            as community value in range from [1-4294967295] or value in aa:nn
            format(aa/nn range from 1-65535). LargeBGPCommunity BGP large
            community which includes community value in aa:bb:nn format where
            aa, bb, nn are unsigned integers in the range [1-4294967295].
        :type  logical_router_id: :class:`str` or ``None``
        :param logical_router_id: Logical router id
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.communities = communities
        self.community_type = community_type
        self.logical_router_id = logical_router_id
        VapiStruct.__init__(self)


BGPCommunityList._set_binding_type(type.StructType(
    'com.vmware.nsx.model.BGP_community_list', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'communities': type.OptionalType(type.ListType(type.StringType())),
        'community_type': type.OptionalType(type.StringType()),
        'logical_router_id': type.OptionalType(type.StringType()),
    },
    BGPCommunityList,
    False,
    None))



class BGPCommunityListListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`BGPCommunityList` or ``None``
        :param results: Paginated list of bgp community lists
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


BGPCommunityListListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.BGP_community_list_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'BGPCommunityList'))),
    },
    BGPCommunityListListResult,
    False,
    None))



class BackupConfiguration(VapiStruct):
    """
    Configuration for taking manual/automated backup

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'after_inventory_update_interval': 'after_inventory_update_interval',
                            'backup_enabled': 'backup_enabled',
                            'backup_schedule': 'backup_schedule',
                            'inventory_summary_interval': 'inventory_summary_interval',
                            'passphrase': 'passphrase',
                            'remote_file_server': 'remote_file_server',
                            }

    def __init__(self,
                 after_inventory_update_interval=None,
                 backup_enabled=None,
                 backup_schedule=None,
                 inventory_summary_interval=None,
                 passphrase=None,
                 remote_file_server=None,
                ):
        """
        :type  after_inventory_update_interval: :class:`long` or ``None``
        :param after_inventory_update_interval: A number of seconds after a last backup, that needs to pass, before
            a topology change will trigger a generation of a new cluster/node
            backups. If parameter is not provided, then changes in a topology
            will not trigger a generation of cluster/node backups. format:
            int64
        :type  backup_enabled: :class:`bool` or ``None``
        :param backup_enabled: true if automated backup is enabled
        :type  backup_schedule: :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param backup_schedule: Set when backups should be taken - on a weekly schedule or at
            regular intervals.
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`BackupSchedule`. When methods return a value of this class
            as a return value, the attribute will contain all the attributes
            defined in :class:`BackupSchedule`.
        :type  inventory_summary_interval: :class:`long` or ``None``
        :param inventory_summary_interval: The minimum number of seconds between each upload of the inventory
            summary to backup server. format: int64
        :type  passphrase: :class:`str` or ``None``
        :param passphrase: Passphrase used to encrypt backup files. The passphrase specified
            must be at least 8 characters in length and must contain at least
            one lowercase, one uppercase, one numeric character and one special
            character (any other non-space character).
        :type  remote_file_server: :class:`RemoteFileServer` or ``None``
        :param remote_file_server: The server to which backups will be sent.
        """
        self.after_inventory_update_interval = after_inventory_update_interval
        self.backup_enabled = backup_enabled
        self.backup_schedule = backup_schedule
        self.inventory_summary_interval = inventory_summary_interval
        self.passphrase = passphrase
        self.remote_file_server = remote_file_server
        VapiStruct.__init__(self)


BackupConfiguration._set_binding_type(type.StructType(
    'com.vmware.nsx.model.backup_configuration', {
        'after_inventory_update_interval': type.OptionalType(type.IntegerType()),
        'backup_enabled': type.OptionalType(type.BooleanType()),
        'backup_schedule': type.OptionalType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'BackupSchedule')])),
        'inventory_summary_interval': type.OptionalType(type.IntegerType()),
        'passphrase': type.OptionalType(type.StringType()),
        'remote_file_server': type.OptionalType(type.ReferenceType(__name__, 'RemoteFileServer')),
    },
    BackupConfiguration,
    False,
    None))



class BackupOperationHistory(VapiStruct):
    """
    Past backup operation details

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'cluster_backup_statuses': 'cluster_backup_statuses',
                            'inventory_backup_statuses': 'inventory_backup_statuses',
                            'node_backup_statuses': 'node_backup_statuses',
                            }

    def __init__(self,
                 cluster_backup_statuses=None,
                 inventory_backup_statuses=None,
                 node_backup_statuses=None,
                ):
        """
        :type  cluster_backup_statuses: :class:`list` of :class:`BackupOperationStatus` or ``None``
        :param cluster_backup_statuses: Statuses of previous cluser backups
        :type  inventory_backup_statuses: :class:`list` of :class:`BackupOperationStatus` or ``None``
        :param inventory_backup_statuses: Statuses of previous inventory backups
        :type  node_backup_statuses: :class:`list` of :class:`BackupOperationStatus` or ``None``
        :param node_backup_statuses: Statuses of previous node backups
        """
        self.cluster_backup_statuses = cluster_backup_statuses
        self.inventory_backup_statuses = inventory_backup_statuses
        self.node_backup_statuses = node_backup_statuses
        VapiStruct.__init__(self)


BackupOperationHistory._set_binding_type(type.StructType(
    'com.vmware.nsx.model.backup_operation_history', {
        'cluster_backup_statuses': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'BackupOperationStatus'))),
        'inventory_backup_statuses': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'BackupOperationStatus'))),
        'node_backup_statuses': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'BackupOperationStatus'))),
    },
    BackupOperationHistory,
    False,
    None))



class BackupOperationStatus(VapiStruct):
    """
    Backup operation status

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    ERROR_CODE_NOT_RUN_ON_MASTER = "BACKUP_NOT_RUN_ON_MASTER"
    """


    """
    ERROR_CODE_SERVER_UNREACHABLE = "BACKUP_SERVER_UNREACHABLE"
    """


    """
    ERROR_CODE_AUTHENTICATION_FAILURE = "BACKUP_AUTHENTICATION_FAILURE"
    """


    """
    ERROR_CODE_PERMISSION_ERROR = "BACKUP_PERMISSION_ERROR"
    """


    """
    ERROR_CODE_TIMEOUT = "BACKUP_TIMEOUT"
    """


    """
    ERROR_CODE_BAD_FINGERPRINT = "BACKUP_BAD_FINGERPRINT"
    """


    """
    ERROR_CODE_GENERIC_ERROR = "BACKUP_GENERIC_ERROR"
    """


    """



    _canonical_to_pep_names = {
                            'backup_id': 'backup_id',
                            'end_time': 'end_time',
                            'error_code': 'error_code',
                            'error_message': 'error_message',
                            'start_time': 'start_time',
                            'success': 'success',
                            }

    def __init__(self,
                 backup_id=None,
                 end_time=None,
                 error_code=None,
                 error_message=None,
                 start_time=None,
                 success=None,
                ):
        """
        :type  backup_id: :class:`str` or ``None``
        :param backup_id: Unique identifier of a backup
        :type  end_time: :class:`long` or ``None``
        :param end_time: Time when operation was ended format: int64
        :type  error_code: :class:`str` or ``None``
        :param error_code: Possible values are: 
            
            * :attr:`BackupOperationStatus.ERROR_CODE_NOT_RUN_ON_MASTER`
            * :attr:`BackupOperationStatus.ERROR_CODE_SERVER_UNREACHABLE`
            * :attr:`BackupOperationStatus.ERROR_CODE_AUTHENTICATION_FAILURE`
            * :attr:`BackupOperationStatus.ERROR_CODE_PERMISSION_ERROR`
            * :attr:`BackupOperationStatus.ERROR_CODE_TIMEOUT`
            * :attr:`BackupOperationStatus.ERROR_CODE_BAD_FINGERPRINT`
            * :attr:`BackupOperationStatus.ERROR_CODE_GENERIC_ERROR`
            
             Error code
        :type  error_message: :class:`str` or ``None``
        :param error_message: Error code details
        :type  start_time: :class:`long` or ``None``
        :param start_time: Time when operation was started format: int64
        :type  success: :class:`bool` or ``None``
        :param success: True if backup is successfully completed, else false
        """
        self.backup_id = backup_id
        self.end_time = end_time
        self.error_code = error_code
        self.error_message = error_message
        self.start_time = start_time
        self.success = success
        VapiStruct.__init__(self)


BackupOperationStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.backup_operation_status', {
        'backup_id': type.OptionalType(type.StringType()),
        'end_time': type.OptionalType(type.IntegerType()),
        'error_code': type.OptionalType(type.StringType()),
        'error_message': type.OptionalType(type.StringType()),
        'start_time': type.OptionalType(type.IntegerType()),
        'success': type.OptionalType(type.BooleanType()),
    },
    BackupOperationStatus,
    False,
    None))



class BackupOverview(VapiStruct):
    """
    Data for a single backup/restore card

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            'backup_config': 'backup_config',
                            'backup_operation_history': 'backup_operation_history',
                            'current_backup_operation_status': 'current_backup_operation_status',
                            'restore_status': 'restore_status',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                 backup_config=None,
                 backup_operation_history=None,
                 current_backup_operation_status=None,
                 restore_status=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`ClusterBackupInfo` or ``None``
        :param results: List of timestamps of backed-up cluster files
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  backup_config: :class:`BackupConfiguration` or ``None``
        :param backup_config: Configuration to generate a manual/automated backup
        :type  backup_operation_history: :class:`BackupOperationHistory` or ``None``
        :param backup_operation_history: Status of the last backup execution per component
        :type  current_backup_operation_status: :class:`CurrentBackupOperationStatus` or ``None``
        :param current_backup_operation_status: Backup status decribes type, phase, success/failure and time of a |
            latest backup execution
        :type  restore_status: :class:`ClusterRestoreStatus` or ``None``
        :param restore_status: Status of restore process executing/executed on appliance
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        self.backup_config = backup_config
        self.backup_operation_history = backup_operation_history
        self.current_backup_operation_status = current_backup_operation_status
        self.restore_status = restore_status
        VapiStruct.__init__(self)


BackupOverview._set_binding_type(type.StructType(
    'com.vmware.nsx.model.backup_overview', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ClusterBackupInfo'))),
        'backup_config': type.OptionalType(type.ReferenceType(__name__, 'BackupConfiguration')),
        'backup_operation_history': type.OptionalType(type.ReferenceType(__name__, 'BackupOperationHistory')),
        'current_backup_operation_status': type.OptionalType(type.ReferenceType(__name__, 'CurrentBackupOperationStatus')),
        'restore_status': type.OptionalType(type.ReferenceType(__name__, 'ClusterRestoreStatus')),
    },
    BackupOverview,
    False,
    None))



class BackupSchedule(VapiStruct):
    """
    Abstract base type for Weekly or Interval Backup Schedule

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "BackupSchedule"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    RESOURCE_TYPE_WEEKLYBACKUPSCHEDULE = "WeeklyBackupSchedule"
    """


    """
    RESOURCE_TYPE_INTERVALBACKUPSCHEDULE = "IntervalBackupSchedule"
    """


    """



    _canonical_to_pep_names = {
                            'resource_type': 'resource_type',
                            }

    def __init__(self,
                 resource_type='BackupSchedule',
                ):
        """
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`BackupSchedule.RESOURCE_TYPE_WEEKLYBACKUPSCHEDULE`
            * :attr:`BackupSchedule.RESOURCE_TYPE_INTERVALBACKUPSCHEDULE`
            
             Schedule type
        """
        self._resource_type = resource_type
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

BackupSchedule._set_binding_type(type.StructType(
    'com.vmware.nsx.model.backup_schedule', {
        'resource_type': type.StringType(),
    },
    BackupSchedule,
    False,
    None))



class BackupUiFramesInfo(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    API_ENDPOINT_GLOBAL_MANAGER = "global-manager"
    """


    """
    API_ENDPOINT_NSXAPI = "nsxapi"
    """


    """
    API_ENDPOINT_ICA = "ica"
    """


    """
    FRAME_TYPE_GLOBAL_MANAGER = "GLOBAL_MANAGER"
    """


    """
    FRAME_TYPE_LOCAL_MANAGER = "LOCAL_MANAGER"
    """


    """
    FRAME_TYPE_LOCAL_LOCAL_MANAGER = "LOCAL_LOCAL_MANAGER"
    """


    """
    FRAME_TYPE_NSX_INTELLIGENCE = "NSX_INTELLIGENCE"
    """


    """



    _canonical_to_pep_names = {
                            'api_endpoint': 'api_endpoint',
                            'frame_type': 'frame_type',
                            'site_id': 'site_id',
                            'site_version': 'site_version',
                            }

    def __init__(self,
                 api_endpoint=None,
                 frame_type=None,
                 site_id=None,
                 site_version=None,
                ):
        """
        :type  api_endpoint: :class:`str` or ``None``
        :param api_endpoint: Possible values are: 
            
            * :attr:`BackupUiFramesInfo.API_ENDPOINT_GLOBAL_MANAGER`
            * :attr:`BackupUiFramesInfo.API_ENDPOINT_NSXAPI`
            * :attr:`BackupUiFramesInfo.API_ENDPOINT_ICA`
            
             prefix to be used for api call
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  frame_type: :class:`str` or ``None``
        :param frame_type: Possible values are: 
            
            * :attr:`BackupUiFramesInfo.FRAME_TYPE_GLOBAL_MANAGER`
            * :attr:`BackupUiFramesInfo.FRAME_TYPE_LOCAL_MANAGER`
            * :attr:`BackupUiFramesInfo.FRAME_TYPE_LOCAL_LOCAL_MANAGER`
            * :attr:`BackupUiFramesInfo.FRAME_TYPE_NSX_INTELLIGENCE`
            
             Type of service, for which backup is handled
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  site_id: :class:`str` or ``None``
        :param site_id: Id of the site
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  site_version: :class:`str` or ``None``
        :param site_version: Version of the site
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.api_endpoint = api_endpoint
        self.frame_type = frame_type
        self.site_id = site_id
        self.site_version = site_version
        VapiStruct.__init__(self)


BackupUiFramesInfo._set_binding_type(type.StructType(
    'com.vmware.nsx.model.backup_ui_frames_info', {
        'api_endpoint': type.OptionalType(type.StringType()),
        'frame_type': type.OptionalType(type.StringType()),
        'site_id': type.OptionalType(type.StringType()),
        'site_version': type.OptionalType(type.StringType()),
    },
    BackupUiFramesInfo,
    False,
    None))



class BackupUiFramesInfoList(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'backup_frames_list': 'backup_frames_list',
                            }

    def __init__(self,
                 backup_frames_list=None,
                ):
        """
        :type  backup_frames_list: :class:`list` of :class:`BackupUiFramesInfo` or ``None``
        :param backup_frames_list: List of backup frames(and metadata) to be displayed in UI
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.backup_frames_list = backup_frames_list
        VapiStruct.__init__(self)


BackupUiFramesInfoList._set_binding_type(type.StructType(
    'com.vmware.nsx.model.backup_ui_frames_info_list', {
        'backup_frames_list': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'BackupUiFramesInfo'))),
    },
    BackupUiFramesInfoList,
    False,
    None))



class BaseFirewallProfile(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "BaseFirewallProfile"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    RESOURCE_TYPE_FIREWALLSESSIONTIMERPROFILE = "FirewallSessionTimerProfile"
    """


    """
    RESOURCE_TYPE_FIREWALLCPUMEMTHRESHOLDSPROFILE = "FirewallCpuMemThresholdsProfile"
    """


    """
    RESOURCE_TYPE_FIREWALLFLOODPROTECTIONPROFILE = "FirewallFloodProtectionProfile"
    """


    """
    RESOURCE_TYPE_FIREWALLDNSPROFILE = "FirewallDnsProfile"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='BaseFirewallProfile',
                 tags=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            *
              :attr:`BaseFirewallProfile.RESOURCE_TYPE_FIREWALLSESSIONTIMERPROFILE`
            *
              :attr:`BaseFirewallProfile.RESOURCE_TYPE_FIREWALLCPUMEMTHRESHOLDSPROFILE`
            *
              :attr:`BaseFirewallProfile.RESOURCE_TYPE_FIREWALLFLOODPROTECTIONPROFILE`
            * :attr:`BaseFirewallProfile.RESOURCE_TYPE_FIREWALLDNSPROFILE`
            
             Resource type to use as profile type
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

BaseFirewallProfile._set_binding_type(type.StructType(
    'com.vmware.nsx.model.base_firewall_profile', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
    },
    BaseFirewallProfile,
    False,
    None))



class BaseHostSwitchProfile(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "BaseHostSwitchProfile"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    RESOURCE_TYPE_UPLINKHOSTSWITCHPROFILE = "UplinkHostSwitchProfile"
    """


    """
    RESOURCE_TYPE_LLDPHOSTSWITCHPROFILE = "LldpHostSwitchProfile"
    """


    """
    RESOURCE_TYPE_NIOCPROFILE = "NiocProfile"
    """


    """
    RESOURCE_TYPE_EXTRACONFIGHOSTSWITCHPROFILE = "ExtraConfigHostSwitchProfile"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'required_capabilities': 'required_capabilities',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='BaseHostSwitchProfile',
                 tags=None,
                 required_capabilities=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            *
              :attr:`BaseHostSwitchProfile.RESOURCE_TYPE_UPLINKHOSTSWITCHPROFILE`
            * :attr:`BaseHostSwitchProfile.RESOURCE_TYPE_LLDPHOSTSWITCHPROFILE`
            * :attr:`BaseHostSwitchProfile.RESOURCE_TYPE_NIOCPROFILE`
            *
              :attr:`BaseHostSwitchProfile.RESOURCE_TYPE_EXTRACONFIGHOSTSWITCHPROFILE`
            
             Supported HostSwitch profiles.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  required_capabilities: :class:`list` of :class:`str` or ``None``
        :param required_capabilities: 
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        self.required_capabilities = required_capabilities
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

BaseHostSwitchProfile._set_binding_type(type.StructType(
    'com.vmware.nsx.model.base_host_switch_profile', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'required_capabilities': type.OptionalType(type.ListType(type.StringType())),
    },
    BaseHostSwitchProfile,
    False,
    None))



class BaseNodeAggregateInfo(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'display_name': 'display_name',
                            'id': 'id',
                            'node_interface_properties': 'node_interface_properties',
                            'node_interface_statistics': 'node_interface_statistics',
                            'node_status': 'node_status',
                            'node_status_properties': 'node_status_properties',
                            }

    def __init__(self,
                 display_name=None,
                 id=None,
                 node_interface_properties=None,
                 node_interface_statistics=None,
                 node_status=None,
                 node_status_properties=None,
                ):
        """
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  node_interface_properties: :class:`list` of :class:`NodeInterfaceProperties` or ``None``
        :param node_interface_properties: Array of Node interface statistic properties
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  node_interface_statistics: :class:`list` of :class:`NodeInterfaceStatisticsProperties` or ``None``
        :param node_interface_statistics: Array of Node network interface statistic properties
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  node_status: :class:`ClusterNodeStatus` or ``None``
        :param node_status: 
        :type  node_status_properties: :class:`list` of :class:`NodeStatusProperties` or ``None``
        :param node_status_properties: Time series of the node's system properties
        """
        self.display_name = display_name
        self.id = id
        self.node_interface_properties = node_interface_properties
        self.node_interface_statistics = node_interface_statistics
        self.node_status = node_status
        self.node_status_properties = node_status_properties
        VapiStruct.__init__(self)


BaseNodeAggregateInfo._set_binding_type(type.StructType(
    'com.vmware.nsx.model.base_node_aggregate_info', {
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'node_interface_properties': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NodeInterfaceProperties'))),
        'node_interface_statistics': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NodeInterfaceStatisticsProperties'))),
        'node_status': type.OptionalType(type.ReferenceType(__name__, 'ClusterNodeStatus')),
        'node_status_properties': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NodeStatusProperties'))),
    },
    BaseNodeAggregateInfo,
    False,
    None))



class BaseServiceInstance(VapiStruct):
    """
    The deployment of a registered service. service instance is instantiation
    of service.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "BaseServiceInstance"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    RESOURCE_TYPE_SERVICEINSTANCE = "ServiceInstance"
    """


    """
    RESOURCE_TYPE_BYODSERVICEINSTANCE = "ByodServiceInstance"
    """


    """
    RESOURCE_TYPE_VIRTUALSERVICEINSTANCE = "VirtualServiceInstance"
    """


    """
    ON_FAILURE_POLICY_ALLOW = "ALLOW"
    """


    """
    ON_FAILURE_POLICY_BLOCK = "BLOCK"
    """


    """
    TRANSPORT_TYPE_L2_BRIDGE = "L2_BRIDGE"
    """


    """
    TRANSPORT_TYPE_L3_ROUTED = "L3_ROUTED"
    """


    """
    TRANSPORT_TYPE_NSH = "NSH"
    """


    """
    TRANSPORT_TYPE_NA = "NA"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'on_failure_policy': 'on_failure_policy',
                            'service_id': 'service_id',
                            'transport_type': 'transport_type',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='BaseServiceInstance',
                 tags=None,
                 on_failure_policy=None,
                 service_id=None,
                 transport_type=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`BaseServiceInstance.RESOURCE_TYPE_SERVICEINSTANCE`
            * :attr:`BaseServiceInstance.RESOURCE_TYPE_BYODSERVICEINSTANCE`
            * :attr:`BaseServiceInstance.RESOURCE_TYPE_VIRTUALSERVICEINSTANCE`
            
            ServiceInstance is used when NSX handles the lifecyle of appliance.
            Deployment and appliance related all the information is necessary.
            ByodServiceInstance is a custom instance to be used when NSX is not
            handling the lifecycles of appliance/s. User will manage their own
            appliance (BYOD) to connect with NSX. VirtualServiceInstance is a a
            custom instance to be used when NSX is not handling the lifecycle
            of an appliance and when the user is not bringing their own
            appliance.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  on_failure_policy: :class:`str` or ``None``
        :param on_failure_policy: Possible values are: 
            
            * :attr:`BaseServiceInstance.ON_FAILURE_POLICY_ALLOW`
            * :attr:`BaseServiceInstance.ON_FAILURE_POLICY_BLOCK`
            
            Failure policy of the service instance - if it has to be different
            from the service. By default the service instance inherits the
            FailurePolicy of the service it belongs to.
        :type  service_id: :class:`str` or ``None``
        :param service_id: The Service to which the service instance is associated.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  transport_type: :class:`str` or ``None``
        :param transport_type: Possible values are: 
            
            * :attr:`BaseServiceInstance.TRANSPORT_TYPE_L2_BRIDGE`
            * :attr:`BaseServiceInstance.TRANSPORT_TYPE_L3_ROUTED`
            * :attr:`BaseServiceInstance.TRANSPORT_TYPE_NSH`
            * :attr:`BaseServiceInstance.TRANSPORT_TYPE_NA`
            
            Transport to be used by this service instance for deploying the
            Service-VM. This field is to be set Not Applicable(NA) if the
            service only caters to functionality EPP(Endpoint Protection).
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        self.on_failure_policy = on_failure_policy
        self.service_id = service_id
        self.transport_type = transport_type
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

BaseServiceInstance._set_binding_type(type.StructType(
    'com.vmware.nsx.model.base_service_instance', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'on_failure_policy': type.OptionalType(type.StringType()),
        'service_id': type.OptionalType(type.StringType()),
        'transport_type': type.OptionalType(type.StringType()),
    },
    BaseServiceInstance,
    False,
    None))



class BaseServiceProfile(VapiStruct):
    """
    Base Service Profile

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "BaseServiceProfile"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='BaseServiceProfile',
                 tags=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Service Profile type, for example 'GiServiceProfile',
            'ServiceInsertionServiceProfile'
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

BaseServiceProfile._set_binding_type(type.StructType(
    'com.vmware.nsx.model.base_service_profile', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
    },
    BaseServiceProfile,
    False,
    None))



class BaseSwitchingProfile(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "BaseSwitchingProfile"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'required_capabilities': 'required_capabilities',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='BaseSwitchingProfile',
                 tags=None,
                 required_capabilities=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: 
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  required_capabilities: :class:`list` of :class:`str` or ``None``
        :param required_capabilities: 
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        self.required_capabilities = required_capabilities
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

BaseSwitchingProfile._set_binding_type(type.StructType(
    'com.vmware.nsx.model.base_switching_profile', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'required_capabilities': type.OptionalType(type.ListType(type.StringType())),
    },
    BaseSwitchingProfile,
    False,
    None))



class BasicAuthenticationScheme(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    SCHEME_NAME_BASIC = "basic"
    """


    """



    _canonical_to_pep_names = {
                            'scheme_name': 'scheme_name',
                            'password': 'password',
                            'username': 'username',
                            }

    def __init__(self,
                 scheme_name=None,
                 password=None,
                 username=None,
                ):
        """
        :type  scheme_name: :class:`str` or ``None``
        :param scheme_name: Possible values are: 
            
            * :attr:`BasicAuthenticationScheme.SCHEME_NAME_BASIC`
            
             Authentication scheme name
        :type  password: :class:`str` or ``None``
        :param password: Password to authenticate with
        :type  username: :class:`str` or ``None``
        :param username: User name to authenticate with
        """
        self.scheme_name = scheme_name
        self.password = password
        self.username = username
        VapiStruct.__init__(self)


BasicAuthenticationScheme._set_binding_type(type.StructType(
    'com.vmware.nsx.model.basic_authentication_scheme', {
        'scheme_name': type.OptionalType(type.StringType()),
        'password': type.OptionalType(type.StringType()),
        'username': type.OptionalType(type.StringType()),
    },
    BasicAuthenticationScheme,
    False,
    None))



class BatchRequest(VapiStruct):
    """
    A set of operations to be performed in a single batch

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'continue_on_error': 'continue_on_error',
                            'requests': 'requests',
                            }

    def __init__(self,
                 continue_on_error=None,
                 requests=None,
                ):
        """
        :type  continue_on_error: :class:`bool` or ``None``
        :param continue_on_error: Flag to decide if we will continue processing subsequent requests
            in case of current error for atomic = false.
        :type  requests: :class:`list` of :class:`BatchRequestItem` or ``None``
        :param requests: 
        """
        self.continue_on_error = continue_on_error
        self.requests = requests
        VapiStruct.__init__(self)


BatchRequest._set_binding_type(type.StructType(
    'com.vmware.nsx.model.batch_request', {
        'continue_on_error': type.OptionalType(type.BooleanType()),
        'requests': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'BatchRequestItem'))),
    },
    BatchRequest,
    False,
    None))



class BatchRequestItem(VapiStruct):
    """
    A single request within a batch of operations

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    METHOD_GET = "GET"
    """


    """
    METHOD_POST = "POST"
    """


    """
    METHOD_PUT = "PUT"
    """


    """
    METHOD_DELETE = "DELETE"
    """


    """
    METHOD_PATCH = "PATCH"
    """


    """



    _canonical_to_pep_names = {
                            'body': 'body',
                            'method': 'method',
                            'uri': 'uri',
                            }

    def __init__(self,
                 body=None,
                 method=None,
                 uri=None,
                ):
        """
        :type  body: :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param body: 
        :type  method: :class:`str` or ``None``
        :param method: Possible values are: 
            
            * :attr:`BatchRequestItem.METHOD_GET`
            * :attr:`BatchRequestItem.METHOD_POST`
            * :attr:`BatchRequestItem.METHOD_PUT`
            * :attr:`BatchRequestItem.METHOD_DELETE`
            * :attr:`BatchRequestItem.METHOD_PATCH`
            
             http method type
        :type  uri: :class:`str` or ``None``
        :param uri: relative uri (path and args), of the call including resource id (if
            this is a POST/DELETE), exclude hostname and port and prefix,
            exploded form of parameters
        """
        self.body = body
        self.method = method
        self.uri = uri
        VapiStruct.__init__(self)


BatchRequestItem._set_binding_type(type.StructType(
    'com.vmware.nsx.model.batch_request_item', {
        'body': type.OptionalType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct)),
        'method': type.OptionalType(type.StringType()),
        'uri': type.OptionalType(type.StringType()),
    },
    BatchRequestItem,
    False,
    None))



class BatchResponse(VapiStruct):
    """
    The reponse to a batch operation

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'has_errors': 'has_errors',
                            'results': 'results',
                            'rolled_back': 'rolled_back',
                            }

    def __init__(self,
                 has_errors=None,
                 results=None,
                 rolled_back=None,
                ):
        """
        :type  has_errors: :class:`bool` or ``None``
        :param has_errors: Indicates if any of the APIs failed
        :type  results: :class:`list` of :class:`BatchResponseItem` or ``None``
        :param results: Bulk list results
        :type  rolled_back: :class:`bool` or ``None``
        :param rolled_back: Optional flag indicating that all items were rolled back even if
            succeeded initially
        """
        self.has_errors = has_errors
        self.results = results
        self.rolled_back = rolled_back
        VapiStruct.__init__(self)


BatchResponse._set_binding_type(type.StructType(
    'com.vmware.nsx.model.batch_response', {
        'has_errors': type.OptionalType(type.BooleanType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'BatchResponseItem'))),
        'rolled_back': type.OptionalType(type.BooleanType()),
    },
    BatchResponse,
    False,
    None))



class BatchResponseItem(VapiStruct):
    """
    A single respose in a list of batched responses

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'body': 'body',
                            'code': 'code',
                            'headers': 'headers',
                            }

    def __init__(self,
                 body=None,
                 code=None,
                 headers=None,
                ):
        """
        :type  body: :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param body: object returned by api
        :type  code: :class:`long` or ``None``
        :param code: http status code format: int64
        :type  headers: :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param headers: The headers returned by the API call
        """
        self.body = body
        self.code = code
        self.headers = headers
        VapiStruct.__init__(self)


BatchResponseItem._set_binding_type(type.StructType(
    'com.vmware.nsx.model.batch_response_item', {
        'body': type.OptionalType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct)),
        'code': type.OptionalType(type.IntegerType()),
        'headers': type.OptionalType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct)),
    },
    BatchResponseItem,
    False,
    None))



class BfdConfig(VapiStruct):
    """
    BFD configuration for LogicalRouter

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'declare_dead_multiple': 'declare_dead_multiple',
                            'enabled': 'enabled',
                            'logical_router_id': 'logical_router_id',
                            'receive_interval': 'receive_interval',
                            'transmit_interval': 'transmit_interval',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 declare_dead_multiple=None,
                 enabled=None,
                 logical_router_id=None,
                 receive_interval=None,
                 transmit_interval=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  declare_dead_multiple: :class:`long` or ``None``
        :param declare_dead_multiple: Number of times a packet is missed before BFD declares the neighbor
            down. format: int64
        :type  enabled: :class:`bool` or ``None``
        :param enabled: Flag to enable BFD for this LogicalRouter
        :type  logical_router_id: :class:`str` or ``None``
        :param logical_router_id: Logical router id
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  receive_interval: :class:`long` or ``None``
        :param receive_interval: the time interval (in milliseconds) between heartbeat packets for
            BFD when receiving heartbeats. format: int64
        :type  transmit_interval: :class:`long` or ``None``
        :param transmit_interval: the time interval (in milliseconds) between heartbeat packets for
            BFD when sending heartbeats. format: int64
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.declare_dead_multiple = declare_dead_multiple
        self.enabled = enabled
        self.logical_router_id = logical_router_id
        self.receive_interval = receive_interval
        self.transmit_interval = transmit_interval
        VapiStruct.__init__(self)


BfdConfig._set_binding_type(type.StructType(
    'com.vmware.nsx.model.bfd_config', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'declare_dead_multiple': type.OptionalType(type.IntegerType()),
        'enabled': type.OptionalType(type.BooleanType()),
        'logical_router_id': type.OptionalType(type.StringType()),
        'receive_interval': type.OptionalType(type.IntegerType()),
        'transmit_interval': type.OptionalType(type.IntegerType()),
    },
    BfdConfig,
    False,
    None))



class BfdConfigParameters(VapiStruct):
    """
    BFD configuration for the given Peer.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'declare_dead_multiple': 'declare_dead_multiple',
                            'receive_interval': 'receive_interval',
                            'transmit_interval': 'transmit_interval',
                            }

    def __init__(self,
                 declare_dead_multiple=None,
                 receive_interval=None,
                 transmit_interval=None,
                ):
        """
        :type  declare_dead_multiple: :class:`long` or ``None``
        :param declare_dead_multiple: Number of times a packet is missed before BFD declares the neighbor
            down. format: int64
        :type  receive_interval: :class:`long` or ``None``
        :param receive_interval: The time interval (in milliseconds) between heartbeat packets for
            BFD when receiving heartbeats.| For edge cluster type of bare
            metal, this value should be >= 50ms.| For edge cluster type of
            virtual machine or hybrid, this value should be >= 500ms. format:
            int64
        :type  transmit_interval: :class:`long` or ``None``
        :param transmit_interval: The time interval (in milliseconds) between heartbeat packets for
            BFD when sending heartbeats.| For edge cluster type of bare metal,
            this value should be >= 300ms.| For edge cluster type of virtual
            machine or hybrid, this value should be >= 1000ms. format: int64
        """
        self.declare_dead_multiple = declare_dead_multiple
        self.receive_interval = receive_interval
        self.transmit_interval = transmit_interval
        VapiStruct.__init__(self)


BfdConfigParameters._set_binding_type(type.StructType(
    'com.vmware.nsx.model.bfd_config_parameters', {
        'declare_dead_multiple': type.OptionalType(type.IntegerType()),
        'receive_interval': type.OptionalType(type.IntegerType()),
        'transmit_interval': type.OptionalType(type.IntegerType()),
    },
    BfdConfigParameters,
    False,
    None))



class BfdHealthMonitoringProfile(VapiStruct):
    """
    Profile for BFD health monitoring

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "BfdHealthMonitoringProfile"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'enabled': 'enabled',
                            'latency_enabled': 'latency_enabled',
                            'probe_interval': 'probe_interval',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            }

    def __init__(self,
                 enabled=None,
                 latency_enabled=None,
                 probe_interval=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='BfdHealthMonitoringProfile',
                 tags=None,
                ):
        """
        :type  enabled: :class:`bool` or ``None``
        :param enabled: Whether the heartbeat is enabled. A POST or PUT request with
            \"enabled\" false (with no probe intervals) will set (POST) or
            reset (PUT) the probe_interval to their default value.
        :type  latency_enabled: :class:`bool` or ``None``
        :param latency_enabled: The flag is to turn on/off latency. A POST or PUT request with
            \"latency_enabled\" true will enable NSX to send the networking
            latency data to thrid-party monitoring tools like vRNI.
        :type  probe_interval: :class:`long` or ``None``
        :param probe_interval: The time interval (in millisec) between probe packets for tunnels
            between transport nodes. format: int64
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            *
              :attr:`TransportZoneProfile.RESOURCE_TYPE_BFDHEALTHMONITORINGPROFILE`
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        """
        self.enabled = enabled
        self.latency_enabled = latency_enabled
        self.probe_interval = probe_interval
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

BfdHealthMonitoringProfile._set_binding_type(type.StructType(
    'com.vmware.nsx.model.bfd_health_monitoring_profile', {
        'enabled': type.OptionalType(type.BooleanType()),
        'latency_enabled': type.OptionalType(type.BooleanType()),
        'probe_interval': type.OptionalType(type.IntegerType()),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
    },
    BfdHealthMonitoringProfile,
    False,
    None))



class BgpAddressFamily(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    TYPE_IPV4_UNICAST = "IPV4_UNICAST"
    """


    """
    TYPE_VPNV4_UNICAST = "VPNV4_UNICAST"
    """


    """
    TYPE_IPV6_UNICAST = "IPV6_UNICAST"
    """


    """
    TYPE_L2VPN_EVPN = "L2VPN_EVPN"
    """


    """



    _canonical_to_pep_names = {
                            'in_prefix_count': 'in_prefix_count',
                            'out_prefix_count': 'out_prefix_count',
                            'type': 'type',
                            }

    def __init__(self,
                 in_prefix_count=None,
                 out_prefix_count=None,
                 type=None,
                ):
        """
        :type  in_prefix_count: :class:`long` or ``None``
        :param in_prefix_count: Count of in prefixes format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  out_prefix_count: :class:`long` or ``None``
        :param out_prefix_count: Count of out prefixes format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  type: :class:`str` or ``None``
        :param type: Possible values are: 
            
            * :attr:`BgpAddressFamily.TYPE_IPV4_UNICAST`
            * :attr:`BgpAddressFamily.TYPE_VPNV4_UNICAST`
            * :attr:`BgpAddressFamily.TYPE_IPV6_UNICAST`
            * :attr:`BgpAddressFamily.TYPE_L2VPN_EVPN`
            
             BGP address family type
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.in_prefix_count = in_prefix_count
        self.out_prefix_count = out_prefix_count
        self.type = type
        VapiStruct.__init__(self)


BgpAddressFamily._set_binding_type(type.StructType(
    'com.vmware.nsx.model.bgp_address_family', {
        'in_prefix_count': type.OptionalType(type.IntegerType()),
        'out_prefix_count': type.OptionalType(type.IntegerType()),
        'type': type.OptionalType(type.StringType()),
    },
    BgpAddressFamily,
    False,
    None))



class BgpConfig(VapiStruct):
    """
    BGP configuration for Tier0 logical router. We create BGP configuration
    while creation of Tier0 logical router.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'as_num': 'as_num',
                            'as_number': 'as_number',
                            'ecmp': 'ecmp',
                            'enabled': 'enabled',
                            'graceful_restart': 'graceful_restart',
                            'graceful_restart_config': 'graceful_restart_config',
                            'inter_sr_ibgp': 'inter_sr_ibgp',
                            'logical_router_id': 'logical_router_id',
                            'multipath_relax': 'multipath_relax',
                            'route_aggregation': 'route_aggregation',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 as_num=None,
                 as_number=None,
                 ecmp=None,
                 enabled=None,
                 graceful_restart=None,
                 graceful_restart_config=None,
                 inter_sr_ibgp=None,
                 logical_router_id=None,
                 multipath_relax=None,
                 route_aggregation=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  as_num: :class:`str` or ``None``
        :param as_num: For VRF logical router, the as_num from parent logical router will
            be effective.
        :type  as_number: :class:`long` or ``None``
        :param as_number: This is a deprecated property, Please use 'as_num' instead. For VRF
            logical router, the as_number from parent logical router will be
            effective. format: int64
        :type  ecmp: :class:`bool` or ``None``
        :param ecmp: While creation of BGP config this flag will be set to true User can
            change this value while updating BGP config. If this property is
            not specified in the payload, the default value will be considered
            as true.
        :type  enabled: :class:`bool` or ``None``
        :param enabled: While creation of BGP config this flag will be set to - true for
            Tier0 logical router with Active-Active high-availability mode -
            false for Tier0 logical router with Active-Standby
            high-availanility mode. User can change this value while updating
            the config. If this property is not specified in the payload, the
            default value will be considered as false irrespective of the
            high-availability mode.
        :type  graceful_restart: :class:`bool` or ``None``
        :param graceful_restart: Flag to enable graceful restart. This field is deprecated, kindly
            use graceful_restart_config parameter for graceful restart
            configuration. If both parameters are set and consistent with each
            other [i.e. graceful_restart=false and
            graceful_restart_mode=HELPER_ONLY OR graceful_restart=true and
            graceful_restart_mode=GR_AND_HELPER] then this is allowed, but if
            inconsistent with each other then this is not allowed and
            validation error will be thrown. For VRF logical router, the
            settings from parent logical router will be effective.
        :type  graceful_restart_config: :class:`GracefulRestartConfig` or ``None``
        :param graceful_restart_config: Configuration parameters for BGP Graceful Restart functionality. It
            has graceful_restart_mode and graceful_restart_timer parameters.
            For VRF logical router, the settings from parent logical router
            will be effective.
        :type  inter_sr_ibgp: :class:`InterSRRoutingConfig` or ``None``
        :param inter_sr_ibgp: Inter SR IBGP configuration
        :type  logical_router_id: :class:`str` or ``None``
        :param logical_router_id: Logical router id
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  multipath_relax: :class:`bool` or ``None``
        :param multipath_relax: For TIER0 logical router, default is true. For VRF logical router,
            the settings from parent logical router will be effective.
        :type  route_aggregation: :class:`list` of :class:`BgpRouteAggregation` or ``None``
        :param route_aggregation: List of routes to be aggregated
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.as_num = as_num
        self.as_number = as_number
        self.ecmp = ecmp
        self.enabled = enabled
        self.graceful_restart = graceful_restart
        self.graceful_restart_config = graceful_restart_config
        self.inter_sr_ibgp = inter_sr_ibgp
        self.logical_router_id = logical_router_id
        self.multipath_relax = multipath_relax
        self.route_aggregation = route_aggregation
        VapiStruct.__init__(self)


BgpConfig._set_binding_type(type.StructType(
    'com.vmware.nsx.model.bgp_config', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'as_num': type.OptionalType(type.StringType()),
        'as_number': type.OptionalType(type.IntegerType()),
        'ecmp': type.OptionalType(type.BooleanType()),
        'enabled': type.OptionalType(type.BooleanType()),
        'graceful_restart': type.OptionalType(type.BooleanType()),
        'graceful_restart_config': type.OptionalType(type.ReferenceType(__name__, 'GracefulRestartConfig')),
        'inter_sr_ibgp': type.OptionalType(type.ReferenceType(__name__, 'InterSRRoutingConfig')),
        'logical_router_id': type.OptionalType(type.StringType()),
        'multipath_relax': type.OptionalType(type.BooleanType()),
        'route_aggregation': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'BgpRouteAggregation'))),
    },
    BgpConfig,
    False,
    None))



class BgpNeighbor(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    GRACEFUL_RESTART_MODE_DISABLE = "DISABLE"
    """


    """
    GRACEFUL_RESTART_MODE_HELPER_ONLY = "HELPER_ONLY"
    """


    """
    GRACEFUL_RESTART_MODE_GR_AND_HELPER = "GR_AND_HELPER"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'address_families': 'address_families',
                            'allow_as_in': 'allow_as_in',
                            'bfd_config': 'bfd_config',
                            'enable_bfd': 'enable_bfd',
                            'enabled': 'enabled',
                            'filter_in_ipprefixlist_id': 'filter_in_ipprefixlist_id',
                            'filter_in_routemap_id': 'filter_in_routemap_id',
                            'filter_out_ipprefixlist_id': 'filter_out_ipprefixlist_id',
                            'filter_out_routemap_id': 'filter_out_routemap_id',
                            'graceful_restart_mode': 'graceful_restart_mode',
                            'hold_down_timer': 'hold_down_timer',
                            'keep_alive_timer': 'keep_alive_timer',
                            'logical_router_id': 'logical_router_id',
                            'maximum_hop_limit': 'maximum_hop_limit',
                            'neighbor_address': 'neighbor_address',
                            'password': 'password',
                            'remote_as': 'remote_as',
                            'remote_as_num': 'remote_as_num',
                            'source_address': 'source_address',
                            'source_addresses': 'source_addresses',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 address_families=None,
                 allow_as_in=None,
                 bfd_config=None,
                 enable_bfd=None,
                 enabled=None,
                 filter_in_ipprefixlist_id=None,
                 filter_in_routemap_id=None,
                 filter_out_ipprefixlist_id=None,
                 filter_out_routemap_id=None,
                 graceful_restart_mode=None,
                 hold_down_timer=None,
                 keep_alive_timer=None,
                 logical_router_id=None,
                 maximum_hop_limit=None,
                 neighbor_address=None,
                 password=None,
                 remote_as=None,
                 remote_as_num=None,
                 source_address=None,
                 source_addresses=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  address_families: :class:`list` of :class:`BgpNeighborAddressFamily` or ``None``
        :param address_families: User can enable the neighbor for the specific address families and
            also define filters per address family. When the neighbor is
            created, it is default enabled for IPV4_UNICAST address family for
            backward compatibility reasons. User can change that if required,
            by defining the address family configuration.
        :type  allow_as_in: :class:`bool` or ``None``
        :param allow_as_in: Flag to enable allowas_in option for BGP neighbor
        :type  bfd_config: :class:`BfdConfigParameters` or ``None``
        :param bfd_config: By specifying these paramaters BFD config for this given peer can
            be overriden | (the globally configured values will not apply for
            this peer)
        :type  enable_bfd: :class:`bool` or ``None``
        :param enable_bfd: Flag to enable BFD for this BGP Neighbor. Enable this if the
            neighbor supports BFD as this will lead to faster convergence.
        :type  enabled: :class:`bool` or ``None``
        :param enabled: Flag to enable this BGP Neighbor
        :type  filter_in_ipprefixlist_id: :class:`str` or ``None``
        :param filter_in_ipprefixlist_id: This is a deprecated property, Please use 'address_family' instead.
        :type  filter_in_routemap_id: :class:`str` or ``None``
        :param filter_in_routemap_id: This is a deprecated property, Please use 'address_family' instead.
        :type  filter_out_ipprefixlist_id: :class:`str` or ``None``
        :param filter_out_ipprefixlist_id: This is a deprecated property, Please use 'address_family' instead.
        :type  filter_out_routemap_id: :class:`str` or ``None``
        :param filter_out_routemap_id: This is a deprecated property, Please use 'address_family' instead.
        :type  graceful_restart_mode: :class:`str` or ``None``
        :param graceful_restart_mode: Possible values are: 
            
            * :attr:`BgpNeighbor.GRACEFUL_RESTART_MODE_DISABLE`
            * :attr:`BgpNeighbor.GRACEFUL_RESTART_MODE_HELPER_ONLY`
            * :attr:`BgpNeighbor.GRACEFUL_RESTART_MODE_GR_AND_HELPER`
            
            BGP Graceful Restart mode. If specified, then it will take
            precedence over global Graceful Restart mode configured in logical
            router BgpConfig otherwise BgpConfig level Graceful Restart mode
            will be applicable for peer.
        :type  hold_down_timer: :class:`long` or ``None``
        :param hold_down_timer: Wait period (seconds) before declaring peer dead format: int64
        :type  keep_alive_timer: :class:`long` or ``None``
        :param keep_alive_timer: Frequency (seconds) with which keep alive messages are sent to
            peers format: int64
        :type  logical_router_id: :class:`str` or ``None``
        :param logical_router_id: Logical router id
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  maximum_hop_limit: :class:`long` or ``None``
        :param maximum_hop_limit: This value is set on TTL(time to live) of BGP header. When router
            receives the BGP packet, it decrements the TTL. The default value
            of TTL is one when BPG request is initiated.So in the case of a BGP
            peer multiple hops away and and value of TTL is one, then next
            router in the path will decrement the TTL to 0, realize it cant
            forward the packet and will drop it. If the hop count value to
            reach neighbor is equal to or less than the maximum_hop_limit value
            then intermediate router decrements the TTL count by one and
            forwards the request to BGP neighour. If the hop count value is
            greater than the maximum_hop_limit value then intermediate router
            discards the request when TTL becomes 0. format: int32
        :type  neighbor_address: :class:`str` or ``None``
        :param neighbor_address: Neighbor IP Address format: ip
        :type  password: :class:`str` or ``None``
        :param password: User can create (POST) the neighbor with or without the password.
            The view (GET) on the neighbor, would never reveal if the password
            is set or not. The password can be set later using edit neighbor
            workFlow (PUT) On the edit neighbor (PUT), if the user does not
            specify the password property, the older value is retained. Maximum
            length of this field is 20 characters.
        :type  remote_as: :class:`long` or ``None``
        :param remote_as: This is a deprecated property, Please use 'remote_as_num' instead.
            format: int64
        :type  remote_as_num: :class:`str` or ``None``
        :param remote_as_num: 4 Byte ASN of the neighbor in ASPLAIN/ASDOT Format
        :type  source_address: :class:`str` or ``None``
        :param source_address: Deprecated - do not provide a value for this field. Use
            source_addresses instead. format: ip
        :type  source_addresses: :class:`list` of :class:`str` or ``None``
        :param source_addresses: BGP neighborship will be formed from all these source addresses to
            this neighbour. format: ip
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.address_families = address_families
        self.allow_as_in = allow_as_in
        self.bfd_config = bfd_config
        self.enable_bfd = enable_bfd
        self.enabled = enabled
        self.filter_in_ipprefixlist_id = filter_in_ipprefixlist_id
        self.filter_in_routemap_id = filter_in_routemap_id
        self.filter_out_ipprefixlist_id = filter_out_ipprefixlist_id
        self.filter_out_routemap_id = filter_out_routemap_id
        self.graceful_restart_mode = graceful_restart_mode
        self.hold_down_timer = hold_down_timer
        self.keep_alive_timer = keep_alive_timer
        self.logical_router_id = logical_router_id
        self.maximum_hop_limit = maximum_hop_limit
        self.neighbor_address = neighbor_address
        self.password = password
        self.remote_as = remote_as
        self.remote_as_num = remote_as_num
        self.source_address = source_address
        self.source_addresses = source_addresses
        VapiStruct.__init__(self)


BgpNeighbor._set_binding_type(type.StructType(
    'com.vmware.nsx.model.bgp_neighbor', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'address_families': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'BgpNeighborAddressFamily'))),
        'allow_as_in': type.OptionalType(type.BooleanType()),
        'bfd_config': type.OptionalType(type.ReferenceType(__name__, 'BfdConfigParameters')),
        'enable_bfd': type.OptionalType(type.BooleanType()),
        'enabled': type.OptionalType(type.BooleanType()),
        'filter_in_ipprefixlist_id': type.OptionalType(type.StringType()),
        'filter_in_routemap_id': type.OptionalType(type.StringType()),
        'filter_out_ipprefixlist_id': type.OptionalType(type.StringType()),
        'filter_out_routemap_id': type.OptionalType(type.StringType()),
        'graceful_restart_mode': type.OptionalType(type.StringType()),
        'hold_down_timer': type.OptionalType(type.IntegerType()),
        'keep_alive_timer': type.OptionalType(type.IntegerType()),
        'logical_router_id': type.OptionalType(type.StringType()),
        'maximum_hop_limit': type.OptionalType(type.IntegerType()),
        'neighbor_address': type.OptionalType(type.StringType()),
        'password': type.OptionalType(type.StringType()),
        'remote_as': type.OptionalType(type.IntegerType()),
        'remote_as_num': type.OptionalType(type.StringType()),
        'source_address': type.OptionalType(type.StringType()),
        'source_addresses': type.OptionalType(type.ListType(type.StringType())),
    },
    BgpNeighbor,
    False,
    None))



class BgpNeighborAddressFamily(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    TYPE_IPV4_UNICAST = "IPV4_UNICAST"
    """


    """
    TYPE_VPNV4_UNICAST = "VPNV4_UNICAST"
    """


    """
    TYPE_IPV6_UNICAST = "IPV6_UNICAST"
    """


    """
    TYPE_L2VPN_EVPN = "L2VPN_EVPN"
    """


    """



    _canonical_to_pep_names = {
                            'enabled': 'enabled',
                            'in_filter_ipprefixlist_id': 'in_filter_ipprefixlist_id',
                            'in_filter_routemap_id': 'in_filter_routemap_id',
                            'maximum_routes': 'maximum_routes',
                            'out_filter_ipprefixlist_id': 'out_filter_ipprefixlist_id',
                            'out_filter_routemap_id': 'out_filter_routemap_id',
                            'type': 'type',
                            }

    def __init__(self,
                 enabled=None,
                 in_filter_ipprefixlist_id=None,
                 in_filter_routemap_id=None,
                 maximum_routes=None,
                 out_filter_ipprefixlist_id=None,
                 out_filter_routemap_id=None,
                 type=None,
                ):
        """
        :type  enabled: :class:`bool` or ``None``
        :param enabled: Enable this address family
        :type  in_filter_ipprefixlist_id: :class:`str` or ``None``
        :param in_filter_ipprefixlist_id: Id of the IPPrefix List to be used for IN direction filter
        :type  in_filter_routemap_id: :class:`str` or ``None``
        :param in_filter_routemap_id: Id of the RouteMap to be used for IN direction filter
        :type  maximum_routes: :class:`long` or ``None``
        :param maximum_routes: Maximum number of routes supported on the address family format:
            int64
        :type  out_filter_ipprefixlist_id: :class:`str` or ``None``
        :param out_filter_ipprefixlist_id: Id of the IPPrefixList to be used for OUT direction filter
        :type  out_filter_routemap_id: :class:`str` or ``None``
        :param out_filter_routemap_id: Id of the RouteMap to be used for OUT direction filter
        :type  type: :class:`str` or ``None``
        :param type: Possible values are: 
            
            * :attr:`BgpNeighborAddressFamily.TYPE_IPV4_UNICAST`
            * :attr:`BgpNeighborAddressFamily.TYPE_VPNV4_UNICAST`
            * :attr:`BgpNeighborAddressFamily.TYPE_IPV6_UNICAST`
            * :attr:`BgpNeighborAddressFamily.TYPE_L2VPN_EVPN`
            
             Address family type
        """
        self.enabled = enabled
        self.in_filter_ipprefixlist_id = in_filter_ipprefixlist_id
        self.in_filter_routemap_id = in_filter_routemap_id
        self.maximum_routes = maximum_routes
        self.out_filter_ipprefixlist_id = out_filter_ipprefixlist_id
        self.out_filter_routemap_id = out_filter_routemap_id
        self.type = type
        VapiStruct.__init__(self)


BgpNeighborAddressFamily._set_binding_type(type.StructType(
    'com.vmware.nsx.model.bgp_neighbor_address_family', {
        'enabled': type.OptionalType(type.BooleanType()),
        'in_filter_ipprefixlist_id': type.OptionalType(type.StringType()),
        'in_filter_routemap_id': type.OptionalType(type.StringType()),
        'maximum_routes': type.OptionalType(type.IntegerType()),
        'out_filter_ipprefixlist_id': type.OptionalType(type.StringType()),
        'out_filter_routemap_id': type.OptionalType(type.StringType()),
        'type': type.OptionalType(type.StringType()),
    },
    BgpNeighborAddressFamily,
    False,
    None))



class BgpNeighborListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`BgpNeighbor` or ``None``
        :param results: Paginated list of bgp neighbors
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


BgpNeighborListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.bgp_neighbor_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'BgpNeighbor'))),
    },
    BgpNeighborListResult,
    False,
    None))



class BgpNeighborRouteDetails(VapiStruct):
    """
    BGP neighbor learned/advertised route details.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'logical_router_id': 'logical_router_id',
                            'neighbor_address': 'neighbor_address',
                            'neighbor_id': 'neighbor_id',
                            'per_transport_node_routes': 'per_transport_node_routes',
                            }

    def __init__(self,
                 logical_router_id=None,
                 neighbor_address=None,
                 neighbor_id=None,
                 per_transport_node_routes=None,
                ):
        """
        :type  logical_router_id: :class:`str` or ``None``
        :param logical_router_id: Logical router id
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  neighbor_address: :class:`str` or ``None``
        :param neighbor_address: BGP neighbor peer IP address. format: ip
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  neighbor_id: :class:`str` or ``None``
        :param neighbor_id: BGP neighbor id
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  per_transport_node_routes: :class:`list` of :class:`RoutesPerTransportNode` or ``None``
        :param per_transport_node_routes: Array of BGP neighbor route details per transport node.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.logical_router_id = logical_router_id
        self.neighbor_address = neighbor_address
        self.neighbor_id = neighbor_id
        self.per_transport_node_routes = per_transport_node_routes
        VapiStruct.__init__(self)


BgpNeighborRouteDetails._set_binding_type(type.StructType(
    'com.vmware.nsx.model.bgp_neighbor_route_details', {
        'logical_router_id': type.OptionalType(type.StringType()),
        'neighbor_address': type.OptionalType(type.StringType()),
        'neighbor_id': type.OptionalType(type.StringType()),
        'per_transport_node_routes': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'RoutesPerTransportNode'))),
    },
    BgpNeighborRouteDetails,
    False,
    None))



class BgpNeighborRouteDetailsCsvRecord(VapiStruct):
    """
    BGP neighbor learned/advertised route details.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'as_path': 'as_path',
                            'local_pref': 'local_pref',
                            'logical_router_id': 'logical_router_id',
                            'med': 'med',
                            'neighbor_address': 'neighbor_address',
                            'neighbor_id': 'neighbor_id',
                            'network': 'network',
                            'next_hop': 'next_hop',
                            'source_address': 'source_address',
                            'transport_node_id': 'transport_node_id',
                            'weight': 'weight',
                            }

    def __init__(self,
                 as_path=None,
                 local_pref=None,
                 logical_router_id=None,
                 med=None,
                 neighbor_address=None,
                 neighbor_id=None,
                 network=None,
                 next_hop=None,
                 source_address=None,
                 transport_node_id=None,
                 weight=None,
                ):
        """
        :type  as_path: :class:`str` or ``None``
        :param as_path: BGP AS path attribute.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  local_pref: :class:`long` or ``None``
        :param local_pref: BGP Local Preference attribute. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  logical_router_id: :class:`str` or ``None``
        :param logical_router_id: Logical router id
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  med: :class:`long` or ``None``
        :param med: BGP Multi Exit Discriminator attribute. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  neighbor_address: :class:`str` or ``None``
        :param neighbor_address: BGP neighbor peer IP address. format: ip
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  neighbor_id: :class:`str` or ``None``
        :param neighbor_id: BGP neighbor id
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  network: :class:`str` or ``None``
        :param network: CIDR network address. format: ip-cidr-block
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  next_hop: :class:`str` or ``None``
        :param next_hop: Next hop IP address. format: ip
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  source_address: :class:`str` or ``None``
        :param source_address: BGP neighbor source address. format: ip
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  transport_node_id: :class:`str` or ``None``
        :param transport_node_id: Transport node id
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  weight: :class:`long` or ``None``
        :param weight: BGP Weight attribute. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.as_path = as_path
        self.local_pref = local_pref
        self.logical_router_id = logical_router_id
        self.med = med
        self.neighbor_address = neighbor_address
        self.neighbor_id = neighbor_id
        self.network = network
        self.next_hop = next_hop
        self.source_address = source_address
        self.transport_node_id = transport_node_id
        self.weight = weight
        VapiStruct.__init__(self)


BgpNeighborRouteDetailsCsvRecord._set_binding_type(type.StructType(
    'com.vmware.nsx.model.bgp_neighbor_route_details_csv_record', {
        'as_path': type.OptionalType(type.StringType()),
        'local_pref': type.OptionalType(type.IntegerType()),
        'logical_router_id': type.OptionalType(type.StringType()),
        'med': type.OptionalType(type.IntegerType()),
        'neighbor_address': type.OptionalType(type.StringType()),
        'neighbor_id': type.OptionalType(type.StringType()),
        'network': type.OptionalType(type.StringType()),
        'next_hop': type.OptionalType(type.StringType()),
        'source_address': type.OptionalType(type.StringType()),
        'transport_node_id': type.OptionalType(type.StringType()),
        'weight': type.OptionalType(type.IntegerType()),
    },
    BgpNeighborRouteDetailsCsvRecord,
    False,
    None))



class BgpNeighborRouteDetailsInCsvFormat(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'file_name': 'file_name',
                            'results': 'results',
                            }

    def __init__(self,
                 file_name=None,
                 results=None,
                ):
        """
        :type  file_name: :class:`str` or ``None``
        :param file_name: File name set by HTTP server if API returns CSV result as a file.
        :type  results: :class:`list` of :class:`BgpNeighborRouteDetailsCsvRecord` or ``None``
        :param results: 
        """
        self.file_name = file_name
        self.results = results
        VapiStruct.__init__(self)


BgpNeighborRouteDetailsInCsvFormat._set_binding_type(type.StructType(
    'com.vmware.nsx.model.bgp_neighbor_route_details_in_csv_format', {
        'file_name': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'BgpNeighborRouteDetailsCsvRecord'))),
    },
    BgpNeighborRouteDetailsInCsvFormat,
    False,
    None))



class BgpNeighborStatus(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    CONNECTION_STATE_INVALID = "INVALID"
    """


    """
    CONNECTION_STATE_IDLE = "IDLE"
    """


    """
    CONNECTION_STATE_CONNECT = "CONNECT"
    """


    """
    CONNECTION_STATE_ACTIVE = "ACTIVE"
    """


    """
    CONNECTION_STATE_OPEN_SENT = "OPEN_SENT"
    """


    """
    CONNECTION_STATE_OPEN_CONFIRM = "OPEN_CONFIRM"
    """


    """
    CONNECTION_STATE_ESTABLISHED = "ESTABLISHED"
    """


    """
    CONNECTION_STATE_UNKNOWN = "UNKNOWN"
    """


    """



    _canonical_to_pep_names = {
                            'address_families': 'address_families',
                            'announced_capabilities': 'announced_capabilities',
                            'connection_drop_count': 'connection_drop_count',
                            'connection_state': 'connection_state',
                            'established_connection_count': 'established_connection_count',
                            'graceful_restart': 'graceful_restart',
                            'graceful_restart_mode': 'graceful_restart_mode',
                            'hold_time': 'hold_time',
                            'keep_alive_interval': 'keep_alive_interval',
                            'local_port': 'local_port',
                            'lr_component_id': 'lr_component_id',
                            'messages_received': 'messages_received',
                            'messages_sent': 'messages_sent',
                            'negotiated_capability': 'negotiated_capability',
                            'neighbor_address': 'neighbor_address',
                            'neighbor_router_id': 'neighbor_router_id',
                            'remote_as_number': 'remote_as_number',
                            'remote_port': 'remote_port',
                            'remote_site': 'remote_site',
                            'source_address': 'source_address',
                            'time_since_established': 'time_since_established',
                            'total_in_prefix_count': 'total_in_prefix_count',
                            'total_out_prefix_count': 'total_out_prefix_count',
                            'transport_node': 'transport_node',
                            }

    def __init__(self,
                 address_families=None,
                 announced_capabilities=None,
                 connection_drop_count=None,
                 connection_state=None,
                 established_connection_count=None,
                 graceful_restart=None,
                 graceful_restart_mode=None,
                 hold_time=None,
                 keep_alive_interval=None,
                 local_port=None,
                 lr_component_id=None,
                 messages_received=None,
                 messages_sent=None,
                 negotiated_capability=None,
                 neighbor_address=None,
                 neighbor_router_id=None,
                 remote_as_number=None,
                 remote_port=None,
                 remote_site=None,
                 source_address=None,
                 time_since_established=None,
                 total_in_prefix_count=None,
                 total_out_prefix_count=None,
                 transport_node=None,
                ):
        """
        :type  address_families: :class:`list` of :class:`BgpAddressFamily` or ``None``
        :param address_families: Address families of BGP neighbor
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  announced_capabilities: :class:`list` of :class:`str` or ``None``
        :param announced_capabilities: BGP capabilities sent to BGP neighbor.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  connection_drop_count: :class:`long` or ``None``
        :param connection_drop_count: Count of connection drop format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  connection_state: :class:`str` or ``None``
        :param connection_state: Possible values are: 
            
            * :attr:`BgpNeighborStatus.CONNECTION_STATE_INVALID`
            * :attr:`BgpNeighborStatus.CONNECTION_STATE_IDLE`
            * :attr:`BgpNeighborStatus.CONNECTION_STATE_CONNECT`
            * :attr:`BgpNeighborStatus.CONNECTION_STATE_ACTIVE`
            * :attr:`BgpNeighborStatus.CONNECTION_STATE_OPEN_SENT`
            * :attr:`BgpNeighborStatus.CONNECTION_STATE_OPEN_CONFIRM`
            * :attr:`BgpNeighborStatus.CONNECTION_STATE_ESTABLISHED`
            * :attr:`BgpNeighborStatus.CONNECTION_STATE_UNKNOWN`
            
             Current state of the BGP session.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  established_connection_count: :class:`long` or ``None``
        :param established_connection_count: Count of connections established format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  graceful_restart: :class:`bool` or ``None``
        :param graceful_restart: Current state of graceful restart where graceful_restart = true
            indicates graceful restart is enabled and graceful_restart = false
            indicates graceful restart is disabled. This is deprecated field,
            use graceful_restart_mode instead.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  graceful_restart_mode: :class:`str` or ``None``
        :param graceful_restart_mode: Current state of graceful restart of BGP neighbor. Possible values
            are - 1. GR_AND_HELPER - Graceful restart with Helper 2.
            HELPER_ONLY - Helper only 3. DISABLE - Disabled
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  hold_time: :class:`long` or ``None``
        :param hold_time: Time in ms to wait for HELLO from BGP peer. If a HELLO packet is
            not seen from BGP Peer withing hold_time then BGP neighbor will be
            marked as down. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  keep_alive_interval: :class:`long` or ``None``
        :param keep_alive_interval: Time in ms to wait for HELLO packet from BGP peer format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  local_port: :class:`long` or ``None``
        :param local_port: TCP port number of Local BGP connection format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  lr_component_id: :class:`str` or ``None``
        :param lr_component_id: Logical router component(Service Router/Distributed Router) id
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  messages_received: :class:`long` or ``None``
        :param messages_received: Count of messages received from the neighbor format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  messages_sent: :class:`long` or ``None``
        :param messages_sent: Count of messages sent to the neighbor format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  negotiated_capability: :class:`list` of :class:`str` or ``None``
        :param negotiated_capability: BGP capabilities negotiated with BGP neighbor.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  neighbor_address: :class:`str` or ``None``
        :param neighbor_address: The IP of the BGP neighbor format: ip
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  neighbor_router_id: :class:`str` or ``None``
        :param neighbor_router_id: Router ID of the BGP neighbor. format: ip
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  remote_as_number: :class:`str` or ``None``
        :param remote_as_number: AS number of the BGP neighbor
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  remote_port: :class:`long` or ``None``
        :param remote_port: TCP port number of remote BGP Connection format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  remote_site: :class:`ResourceReference` or ``None``
        :param remote_site: Remote site details.
        :type  source_address: :class:`str` or ``None``
        :param source_address: The Ip address of logical port format: ip
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  time_since_established: :class:`long` or ``None``
        :param time_since_established: Time(in milliseconds) since connection was established. format:
            int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  total_in_prefix_count: :class:`long` or ``None``
        :param total_in_prefix_count: Sum of in prefixes counts across all address families. format:
            int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  total_out_prefix_count: :class:`long` or ``None``
        :param total_out_prefix_count: Sum of out prefixes counts across all address families. format:
            int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  transport_node: :class:`ResourceReference` or ``None``
        :param transport_node: Transport node id and name
        """
        self.address_families = address_families
        self.announced_capabilities = announced_capabilities
        self.connection_drop_count = connection_drop_count
        self.connection_state = connection_state
        self.established_connection_count = established_connection_count
        self.graceful_restart = graceful_restart
        self.graceful_restart_mode = graceful_restart_mode
        self.hold_time = hold_time
        self.keep_alive_interval = keep_alive_interval
        self.local_port = local_port
        self.lr_component_id = lr_component_id
        self.messages_received = messages_received
        self.messages_sent = messages_sent
        self.negotiated_capability = negotiated_capability
        self.neighbor_address = neighbor_address
        self.neighbor_router_id = neighbor_router_id
        self.remote_as_number = remote_as_number
        self.remote_port = remote_port
        self.remote_site = remote_site
        self.source_address = source_address
        self.time_since_established = time_since_established
        self.total_in_prefix_count = total_in_prefix_count
        self.total_out_prefix_count = total_out_prefix_count
        self.transport_node = transport_node
        VapiStruct.__init__(self)


BgpNeighborStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.bgp_neighbor_status', {
        'address_families': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'BgpAddressFamily'))),
        'announced_capabilities': type.OptionalType(type.ListType(type.StringType())),
        'connection_drop_count': type.OptionalType(type.IntegerType()),
        'connection_state': type.OptionalType(type.StringType()),
        'established_connection_count': type.OptionalType(type.IntegerType()),
        'graceful_restart': type.OptionalType(type.BooleanType()),
        'graceful_restart_mode': type.OptionalType(type.StringType()),
        'hold_time': type.OptionalType(type.IntegerType()),
        'keep_alive_interval': type.OptionalType(type.IntegerType()),
        'local_port': type.OptionalType(type.IntegerType()),
        'lr_component_id': type.OptionalType(type.StringType()),
        'messages_received': type.OptionalType(type.IntegerType()),
        'messages_sent': type.OptionalType(type.IntegerType()),
        'negotiated_capability': type.OptionalType(type.ListType(type.StringType())),
        'neighbor_address': type.OptionalType(type.StringType()),
        'neighbor_router_id': type.OptionalType(type.StringType()),
        'remote_as_number': type.OptionalType(type.StringType()),
        'remote_port': type.OptionalType(type.IntegerType()),
        'remote_site': type.OptionalType(type.ReferenceType(__name__, 'ResourceReference')),
        'source_address': type.OptionalType(type.StringType()),
        'time_since_established': type.OptionalType(type.IntegerType()),
        'total_in_prefix_count': type.OptionalType(type.IntegerType()),
        'total_out_prefix_count': type.OptionalType(type.IntegerType()),
        'transport_node': type.OptionalType(type.ReferenceType(__name__, 'ResourceReference')),
    },
    BgpNeighborStatus,
    False,
    None))



class BgpNeighborStatusLiteDto(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    CONNECTION_STATE_INVALID = "INVALID"
    """


    """
    CONNECTION_STATE_IDLE = "IDLE"
    """


    """
    CONNECTION_STATE_CONNECT = "CONNECT"
    """


    """
    CONNECTION_STATE_ACTIVE = "ACTIVE"
    """


    """
    CONNECTION_STATE_OPEN_SENT = "OPEN_SENT"
    """


    """
    CONNECTION_STATE_OPEN_CONFIRM = "OPEN_CONFIRM"
    """


    """
    CONNECTION_STATE_ESTABLISHED = "ESTABLISHED"
    """


    """
    CONNECTION_STATE_UNKNOWN = "UNKNOWN"
    """


    """



    _canonical_to_pep_names = {
                            'connection_state': 'connection_state',
                            'neighbor_address': 'neighbor_address',
                            'remote_site': 'remote_site',
                            'source_address': 'source_address',
                            }

    def __init__(self,
                 connection_state=None,
                 neighbor_address=None,
                 remote_site=None,
                 source_address=None,
                ):
        """
        :type  connection_state: :class:`str` or ``None``
        :param connection_state: Possible values are: 
            
            * :attr:`BgpNeighborStatusLiteDto.CONNECTION_STATE_INVALID`
            * :attr:`BgpNeighborStatusLiteDto.CONNECTION_STATE_IDLE`
            * :attr:`BgpNeighborStatusLiteDto.CONNECTION_STATE_CONNECT`
            * :attr:`BgpNeighborStatusLiteDto.CONNECTION_STATE_ACTIVE`
            * :attr:`BgpNeighborStatusLiteDto.CONNECTION_STATE_OPEN_SENT`
            * :attr:`BgpNeighborStatusLiteDto.CONNECTION_STATE_OPEN_CONFIRM`
            * :attr:`BgpNeighborStatusLiteDto.CONNECTION_STATE_ESTABLISHED`
            * :attr:`BgpNeighborStatusLiteDto.CONNECTION_STATE_UNKNOWN`
            
             Current state of the BGP session.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  neighbor_address: :class:`str` or ``None``
        :param neighbor_address: Ip address of BGP neighbor. format: ip
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  remote_site: :class:`ResourceReference` or ``None``
        :param remote_site: Remote site details.
        :type  source_address: :class:`str` or ``None``
        :param source_address: Source Ip address. format: ip
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.connection_state = connection_state
        self.neighbor_address = neighbor_address
        self.remote_site = remote_site
        self.source_address = source_address
        VapiStruct.__init__(self)


BgpNeighborStatusLiteDto._set_binding_type(type.StructType(
    'com.vmware.nsx.model.bgp_neighbor_status_lite_dto', {
        'connection_state': type.OptionalType(type.StringType()),
        'neighbor_address': type.OptionalType(type.StringType()),
        'remote_site': type.OptionalType(type.ReferenceType(__name__, 'ResourceReference')),
        'source_address': type.OptionalType(type.StringType()),
    },
    BgpNeighborStatusLiteDto,
    False,
    None))



class BgpNeighborsStatusListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'last_update_timestamp': 'last_update_timestamp',
                            'logical_router_id': 'logical_router_id',
                            'logical_router_name': 'logical_router_name',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 last_update_timestamp=None,
                 logical_router_id=None,
                 logical_router_name=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_update_timestamp: :class:`long` or ``None``
        :param last_update_timestamp: Timestamp when the data was last updated, unset if data source has
            never updated the data. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  logical_router_id: :class:`str` or ``None``
        :param logical_router_id: Logical router id
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  logical_router_name: :class:`str` or ``None``
        :param logical_router_name: Name of the logical router
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`BgpNeighborStatus` or ``None``
        :param results: Status of BGP neighbors of the logical router
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.last_update_timestamp = last_update_timestamp
        self.logical_router_id = logical_router_id
        self.logical_router_name = logical_router_name
        self.results = results
        VapiStruct.__init__(self)


BgpNeighborsStatusListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.bgp_neighbors_status_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'last_update_timestamp': type.OptionalType(type.IntegerType()),
        'logical_router_id': type.OptionalType(type.StringType()),
        'logical_router_name': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'BgpNeighborStatus'))),
    },
    BgpNeighborsStatusListResult,
    False,
    None))



class BgpRouteAggregation(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'prefix': 'prefix',
                            'summary_only': 'summary_only',
                            }

    def __init__(self,
                 prefix=None,
                 summary_only=None,
                ):
        """
        :type  prefix: :class:`str` or ``None``
        :param prefix: cidr of the aggregate address format: ip-cidr-block
        :type  summary_only: :class:`bool` or ``None``
        :param summary_only: Flag to send only summarized route
        """
        self.prefix = prefix
        self.summary_only = summary_only
        VapiStruct.__init__(self)


BgpRouteAggregation._set_binding_type(type.StructType(
    'com.vmware.nsx.model.bgp_route_aggregation', {
        'prefix': type.OptionalType(type.StringType()),
        'summary_only': type.OptionalType(type.BooleanType()),
    },
    BgpRouteAggregation,
    False,
    None))



class BinaryPacketData(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "BinaryPacketData"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'payload': 'payload',
                            'frame_size': 'frame_size',
                            'resource_type': 'resource_type',
                            'routed': 'routed',
                            'transport_type': 'transport_type',
                            }

    def __init__(self,
                 payload=None,
                 frame_size=None,
                 resource_type='BinaryPacketData',
                 routed=None,
                 transport_type=None,
                ):
        """
        :type  payload: :class:`str` or ``None``
        :param payload: Up to 1000 bytes of payload may be supplied (with a base64-encoded
            length of 1336 bytes.) Additional bytes of traceflow metadata will
            be appended to the payload. The payload must contain all headers
            (Ethernet, IP, etc). Note that VLAN is not supported in the logical
            space. Hence, payload must not contain 802.1Q headers.
        :type  frame_size: :class:`long` or ``None``
        :param frame_size: If the requested frame_size is too small (given the payload and
            traceflow metadata requirement of 16 bytes), the traceflow request
            will fail with an appropriate message. The frame will be zero
            padded to the requested size. format: int64
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`PacketData.RESOURCE_TYPE_BINARYPACKETDATA`
            * :attr:`PacketData.RESOURCE_TYPE_FIELDSPACKETDATA`
            
             Packet configuration
        :type  routed: :class:`bool` or ``None``
        :param routed: A flag, when set true, indicates that the traceflow packet is of L3
            routing.
        :type  transport_type: :class:`str` or ``None``
        :param transport_type: Possible values are: 
            
            * :attr:`PacketData.TRANSPORT_TYPE_BROADCAST`
            * :attr:`PacketData.TRANSPORT_TYPE_UNICAST`
            * :attr:`PacketData.TRANSPORT_TYPE_MULTICAST`
            * :attr:`PacketData.TRANSPORT_TYPE_UNKNOWN`
            
             transport type of the traceflow packet
        """
        self.payload = payload
        self.frame_size = frame_size
        self._resource_type = resource_type
        self.routed = routed
        self.transport_type = transport_type
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

BinaryPacketData._set_binding_type(type.StructType(
    'com.vmware.nsx.model.binary_packet_data', {
        'payload': type.OptionalType(type.StringType()),
        'frame_size': type.OptionalType(type.IntegerType()),
        'resource_type': type.StringType(),
        'routed': type.OptionalType(type.BooleanType()),
        'transport_type': type.OptionalType(type.StringType()),
    },
    BinaryPacketData,
    False,
    None))



class BpduFilter(VapiStruct):
    """
    BPDU filter configuration

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'enabled': 'enabled',
                            'white_list': 'white_list',
                            }

    def __init__(self,
                 enabled=None,
                 white_list=None,
                ):
        """
        :type  enabled: :class:`bool` or ``None``
        :param enabled: Indicates whether BPDU filter is enabled
        :type  white_list: :class:`list` of :class:`str` or ``None``
        :param white_list: Pre-defined list of allowed MAC addresses to be excluded from BPDU
            filtering
        """
        self.enabled = enabled
        self.white_list = white_list
        VapiStruct.__init__(self)


BpduFilter._set_binding_type(type.StructType(
    'com.vmware.nsx.model.bpdu_filter', {
        'enabled': type.OptionalType(type.BooleanType()),
        'white_list': type.OptionalType(type.ListType(type.StringType())),
    },
    BpduFilter,
    False,
    None))



class BridgeCluster(VapiStruct):
    """
    Bridge Cluster

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'bridge_nodes': 'bridge_nodes',
                            'cluster_profile_bindings': 'cluster_profile_bindings',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 bridge_nodes=None,
                 cluster_profile_bindings=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  bridge_nodes: :class:`list` of :class:`BridgeClusterNode` or ``None``
        :param bridge_nodes: Nodes used in bridging
        :type  cluster_profile_bindings: :class:`list` of :class:`ClusterProfileTypeIdEntry` or ``None``
        :param cluster_profile_bindings: Bridge cluster profile bindings
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.bridge_nodes = bridge_nodes
        self.cluster_profile_bindings = cluster_profile_bindings
        VapiStruct.__init__(self)


BridgeCluster._set_binding_type(type.StructType(
    'com.vmware.nsx.model.bridge_cluster', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'bridge_nodes': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'BridgeClusterNode'))),
        'cluster_profile_bindings': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ClusterProfileTypeIdEntry'))),
    },
    BridgeCluster,
    False,
    None))



class BridgeClusterListResult(VapiStruct):
    """
    Bridge cluster queries result

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`BridgeCluster` or ``None``
        :param results: BridgeCluster Results
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


BridgeClusterListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.bridge_cluster_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'BridgeCluster'))),
    },
    BridgeClusterListResult,
    False,
    None))



class BridgeClusterNode(VapiStruct):
    """
    Bridge transport node

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'ha_mac': 'ha_mac',
                            'transport_node_id': 'transport_node_id',
                            }

    def __init__(self,
                 ha_mac=None,
                 transport_node_id=None,
                ):
        """
        :type  ha_mac: :class:`str` or ``None``
        :param ha_mac: MAC address used for HA protocol format: mac-address
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  transport_node_id: :class:`str` or ``None``
        :param transport_node_id: UUID of the transport node
        """
        self.ha_mac = ha_mac
        self.transport_node_id = transport_node_id
        VapiStruct.__init__(self)


BridgeClusterNode._set_binding_type(type.StructType(
    'com.vmware.nsx.model.bridge_cluster_node', {
        'ha_mac': type.OptionalType(type.StringType()),
        'transport_node_id': type.OptionalType(type.StringType()),
    },
    BridgeClusterNode,
    False,
    None))



class BridgeClusterStatus(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    HEALTH_UP = "UP"
    """


    """
    HEALTH_DOWN = "DOWN"
    """


    """
    HEALTH_DEGRADED = "DEGRADED"
    """


    """
    HEALTH_UNKNOWN = "UNKNOWN"
    """


    """



    _canonical_to_pep_names = {
                            'cluster_id': 'cluster_id',
                            'health': 'health',
                            'last_update_timestamp': 'last_update_timestamp',
                            }

    def __init__(self,
                 cluster_id=None,
                 health=None,
                 last_update_timestamp=None,
                ):
        """
        :type  cluster_id: :class:`str` or ``None``
        :param cluster_id: The id of the cluster
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  health: :class:`str` or ``None``
        :param health: Possible values are: 
            
            * :attr:`BridgeClusterStatus.HEALTH_UP`
            * :attr:`BridgeClusterStatus.HEALTH_DOWN`
            * :attr:`BridgeClusterStatus.HEALTH_DEGRADED`
            * :attr:`BridgeClusterStatus.HEALTH_UNKNOWN`
            
             The health status of the cluster
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_update_timestamp: :class:`long` or ``None``
        :param last_update_timestamp: Timestamp when the data was last updated; unset if data source has
            never updated the data. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.cluster_id = cluster_id
        self.health = health
        self.last_update_timestamp = last_update_timestamp
        VapiStruct.__init__(self)


BridgeClusterStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.bridge_cluster_status', {
        'cluster_id': type.OptionalType(type.StringType()),
        'health': type.OptionalType(type.StringType()),
        'last_update_timestamp': type.OptionalType(type.IntegerType()),
    },
    BridgeClusterStatus,
    False,
    None))



class BridgeEndpoint(VapiStruct):
    """
    A bridge endpoint can be created on a bridge cluster or on an edge cluster.
    Few of the properties of this class will not be used depending on the type
    of bridge endpoint being created. When creating a bridge endpoint on a
    bridge cluster, following propeties will be used: vlan, bridge_cluster_id
    and ha_enable. Similarly, for creating a bridge endpoint on an edge cluster
    following properties will be used: vlan, bridge_endpoint_profile_id and
    vlan_transport_zone_id.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'bridge_cluster_id': 'bridge_cluster_id',
                            'bridge_endpoint_profile_id': 'bridge_endpoint_profile_id',
                            'ha_enable': 'ha_enable',
                            'uplink_teaming_policy_name': 'uplink_teaming_policy_name',
                            'vlan': 'vlan',
                            'vlan_transport_zone_id': 'vlan_transport_zone_id',
                            'vlan_trunk_spec': 'vlan_trunk_spec',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 bridge_cluster_id=None,
                 bridge_endpoint_profile_id=None,
                 ha_enable=None,
                 uplink_teaming_policy_name=None,
                 vlan=None,
                 vlan_transport_zone_id=None,
                 vlan_trunk_spec=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  bridge_cluster_id: :class:`str` or ``None``
        :param bridge_cluster_id: This field will not be used if an edge cluster is being used for
            the bridge endpoint
        :type  bridge_endpoint_profile_id: :class:`str` or ``None``
        :param bridge_endpoint_profile_id: This field will not be used if a bridge cluster is being used for
            the bridge endpoint
        :type  ha_enable: :class:`bool` or ``None``
        :param ha_enable: This field will not be used if an edge cluster is being used for
            the bridge endpoint
        :type  uplink_teaming_policy_name: :class:`str` or ``None``
        :param uplink_teaming_policy_name: This name has to be one of the switching uplink teaming policy
            names listed inside the TransportZone. If this field is not
            specified, bridge will use the first pnic in host-switch config.
            This field will not be used if a bridge cluster is being used for
            the bridge endpoint
        :type  vlan: :class:`long` or ``None``
        :param vlan: This property is used for VLAN specification of bridge endpoint.
            It's mutually exclusive with 'vlan_trunk_spec', either 'vlan' or
            'vlan_trunk_spec' should be specified. format: int64
        :type  vlan_transport_zone_id: :class:`str` or ``None``
        :param vlan_transport_zone_id: This field will not be used if a bridge cluster is being used for
            the bridge endpoint
        :type  vlan_trunk_spec: :class:`VlanTrunkSpec` or ``None``
        :param vlan_trunk_spec: This property is used for VLAN trunk specification of edge bridge
            endpoint. It's mutually exclusive with 'vlan', either 'vlan' or
            'vlan_trunk_spec' should be specified.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.bridge_cluster_id = bridge_cluster_id
        self.bridge_endpoint_profile_id = bridge_endpoint_profile_id
        self.ha_enable = ha_enable
        self.uplink_teaming_policy_name = uplink_teaming_policy_name
        self.vlan = vlan
        self.vlan_transport_zone_id = vlan_transport_zone_id
        self.vlan_trunk_spec = vlan_trunk_spec
        VapiStruct.__init__(self)


BridgeEndpoint._set_binding_type(type.StructType(
    'com.vmware.nsx.model.bridge_endpoint', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'bridge_cluster_id': type.OptionalType(type.StringType()),
        'bridge_endpoint_profile_id': type.OptionalType(type.StringType()),
        'ha_enable': type.OptionalType(type.BooleanType()),
        'uplink_teaming_policy_name': type.OptionalType(type.StringType()),
        'vlan': type.OptionalType(type.IntegerType()),
        'vlan_transport_zone_id': type.OptionalType(type.StringType()),
        'vlan_trunk_spec': type.OptionalType(type.ReferenceType(__name__, 'VlanTrunkSpec')),
    },
    BridgeEndpoint,
    False,
    None))



class BridgeEndpointListResult(VapiStruct):
    """
    Bridge Endpoint queries result

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`BridgeEndpoint` or ``None``
        :param results: BridgeEndpoint Results
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


BridgeEndpointListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.bridge_endpoint_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'BridgeEndpoint'))),
    },
    BridgeEndpointListResult,
    False,
    None))



class BridgeEndpointProfile(VapiStruct):
    """
    Bridge Endpoint Profile

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    FAILOVER_MODE_PREEMPTIVE = "PREEMPTIVE"
    """


    """
    FAILOVER_MODE_NON_PREEMPTIVE = "NON_PREEMPTIVE"
    """


    """
    HIGH_AVAILABILITY_MODE_STANDBY = "ACTIVE_STANDBY"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'edge_cluster_id': 'edge_cluster_id',
                            'edge_cluster_member_indexes': 'edge_cluster_member_indexes',
                            'failover_mode': 'failover_mode',
                            'high_availability_mode': 'high_availability_mode',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 edge_cluster_id=None,
                 edge_cluster_member_indexes=None,
                 failover_mode=None,
                 high_availability_mode=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  edge_cluster_id: :class:`str` or ``None``
        :param edge_cluster_id: UUID of the edge cluster for this bridge endpoint
        :type  edge_cluster_member_indexes: :class:`list` of :class:`long` or ``None``
        :param edge_cluster_member_indexes: First index will be used as the preferred member format: int32
        :type  failover_mode: :class:`str` or ``None``
        :param failover_mode: Possible values are: 
            
            * :attr:`BridgeEndpointProfile.FAILOVER_MODE_PREEMPTIVE`
            * :attr:`BridgeEndpointProfile.FAILOVER_MODE_NON_PREEMPTIVE`
            
             Faileover mode can be preemmptive or non-preemptive
        :type  high_availability_mode: :class:`str` or ``None``
        :param high_availability_mode: Possible values are: 
            
            * :attr:`BridgeEndpointProfile.HIGH_AVAILABILITY_MODE_STANDBY`
            
             High avaialability mode can be active-active or active-standby
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.edge_cluster_id = edge_cluster_id
        self.edge_cluster_member_indexes = edge_cluster_member_indexes
        self.failover_mode = failover_mode
        self.high_availability_mode = high_availability_mode
        VapiStruct.__init__(self)


BridgeEndpointProfile._set_binding_type(type.StructType(
    'com.vmware.nsx.model.bridge_endpoint_profile', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'edge_cluster_id': type.OptionalType(type.StringType()),
        'edge_cluster_member_indexes': type.OptionalType(type.ListType(type.IntegerType())),
        'failover_mode': type.OptionalType(type.StringType()),
        'high_availability_mode': type.OptionalType(type.StringType()),
    },
    BridgeEndpointProfile,
    False,
    None))



class BridgeEndpointProfileListResult(VapiStruct):
    """
    Bridge Endpoint Profile queries result

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`BridgeEndpointProfile` or ``None``
        :param results: BridgeEndpointProfile Results
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


BridgeEndpointProfileListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.bridge_endpoint_profile_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'BridgeEndpointProfile'))),
    },
    BridgeEndpointProfileListResult,
    False,
    None))



class BridgeEndpointStatistics(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'rx_bytes': 'rx_bytes',
                            'rx_packets': 'rx_packets',
                            'tx_bytes': 'tx_bytes',
                            'tx_packets': 'tx_packets',
                            'endpoint_id': 'endpoint_id',
                            'last_update_timestamp': 'last_update_timestamp',
                            }

    def __init__(self,
                 rx_bytes=None,
                 rx_packets=None,
                 tx_bytes=None,
                 tx_packets=None,
                 endpoint_id=None,
                 last_update_timestamp=None,
                ):
        """
        :type  rx_bytes: :class:`DataCounter` or ``None``
        :param rx_bytes: 
        :type  rx_packets: :class:`DataCounter` or ``None``
        :param rx_packets: 
        :type  tx_bytes: :class:`DataCounter` or ``None``
        :param tx_bytes: 
        :type  tx_packets: :class:`DataCounter` or ``None``
        :param tx_packets: 
        :type  endpoint_id: :class:`str` or ``None``
        :param endpoint_id: The id of the bridge endpoint
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_update_timestamp: :class:`long` or ``None``
        :param last_update_timestamp: Timestamp when the data was last updated; unset if data source has
            never updated the data. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.rx_bytes = rx_bytes
        self.rx_packets = rx_packets
        self.tx_bytes = tx_bytes
        self.tx_packets = tx_packets
        self.endpoint_id = endpoint_id
        self.last_update_timestamp = last_update_timestamp
        VapiStruct.__init__(self)


BridgeEndpointStatistics._set_binding_type(type.StructType(
    'com.vmware.nsx.model.bridge_endpoint_statistics', {
        'rx_bytes': type.OptionalType(type.ReferenceType(__name__, 'DataCounter')),
        'rx_packets': type.OptionalType(type.ReferenceType(__name__, 'DataCounter')),
        'tx_bytes': type.OptionalType(type.ReferenceType(__name__, 'DataCounter')),
        'tx_packets': type.OptionalType(type.ReferenceType(__name__, 'DataCounter')),
        'endpoint_id': type.OptionalType(type.StringType()),
        'last_update_timestamp': type.OptionalType(type.IntegerType()),
    },
    BridgeEndpointStatistics,
    False,
    None))



class BridgeEndpointStatus(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'active_nodes': 'active_nodes',
                            'endpoint_id': 'endpoint_id',
                            'last_update_timestamp': 'last_update_timestamp',
                            }

    def __init__(self,
                 active_nodes=None,
                 endpoint_id=None,
                 last_update_timestamp=None,
                ):
        """
        :type  active_nodes: :class:`list` of :class:`str` or ``None``
        :param active_nodes: The Ids of the transport nodes which actively serve the endpoint.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  endpoint_id: :class:`str` or ``None``
        :param endpoint_id: The id of the bridge endpoint
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_update_timestamp: :class:`long` or ``None``
        :param last_update_timestamp: Timestamp when the data was last updated; unset if data source has
            never updated the data. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.active_nodes = active_nodes
        self.endpoint_id = endpoint_id
        self.last_update_timestamp = last_update_timestamp
        VapiStruct.__init__(self)


BridgeEndpointStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.bridge_endpoint_status', {
        'active_nodes': type.OptionalType(type.ListType(type.StringType())),
        'endpoint_id': type.OptionalType(type.StringType()),
        'last_update_timestamp': type.OptionalType(type.IntegerType()),
    },
    BridgeEndpointStatus,
    False,
    None))



class BridgeHighAvailabilityClusterProfile(VapiStruct):
    """
    Profile for BFD HA cluster setting

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "BridgeHighAvailabilityClusterProfile"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'bfd_probe_interval': 'bfd_probe_interval',
                            'enable': 'enable',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            }

    def __init__(self,
                 bfd_probe_interval=None,
                 enable=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='BridgeHighAvailabilityClusterProfile',
                 tags=None,
                ):
        """
        :type  bfd_probe_interval: :class:`long` or ``None``
        :param bfd_probe_interval: the time interval (in millisec) between probe packets for heartbeat
            purpose format: int64
        :type  enable: :class:`bool` or ``None``
        :param enable: whether the heartbeat is enabled
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`ClusterProfile.RESOURCE_TYPE_EDGEHIGHAVAILABILITYPROFILE`
            *
              :attr:`ClusterProfile.RESOURCE_TYPE_BRIDGEHIGHAVAILABILITYCLUSTERPROFILE`
            
             Supported cluster profiles.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        """
        self.bfd_probe_interval = bfd_probe_interval
        self.enable = enable
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

BridgeHighAvailabilityClusterProfile._set_binding_type(type.StructType(
    'com.vmware.nsx.model.bridge_high_availability_cluster_profile', {
        'bfd_probe_interval': type.OptionalType(type.IntegerType()),
        'enable': type.OptionalType(type.BooleanType()),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
    },
    BridgeHighAvailabilityClusterProfile,
    False,
    None))



class BrokerProperties(VapiStruct):
    """
    Information about a management plane node this transport node is configured
    to communicate with

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'BrokerFqdn': 'broker_fqdn',
                            'BrokerIpAddress': 'broker_ip_address',
                            'BrokerIsMaster': 'broker_is_master',
                            'BrokerPort': 'broker_port',
                            'BrokerSslCertThumbprint': 'broker_ssl_cert_thumbprint',
                            'BrokerVirtualHost': 'broker_virtual_host',
                            }

    def __init__(self,
                 broker_fqdn=None,
                 broker_ip_address=None,
                 broker_is_master=None,
                 broker_port=None,
                 broker_ssl_cert_thumbprint=None,
                 broker_virtual_host=None,
                ):
        """
        :type  broker_fqdn: :class:`str` or ``None``
        :param broker_fqdn: Fully qualified domain name of the message bus broker on the
            management plane node.
        :type  broker_ip_address: :class:`str` or ``None``
        :param broker_ip_address: IP address or hostname of the message bus broker on the management
            plane node. format: hostname-or-ipv4
        :type  broker_is_master: :class:`str` or ``None``
        :param broker_is_master: Indicates whether this broker is the master.
        :type  broker_port: :class:`str` or ``None``
        :param broker_port: Port number of the message bus broker on the management plane node.
        :type  broker_ssl_cert_thumbprint: :class:`str` or ``None``
        :param broker_ssl_cert_thumbprint: Certificate thumbprint of the message bus broker on the management
            plane node.
        :type  broker_virtual_host: :class:`str` or ``None``
        :param broker_virtual_host: Type of host running the broker.
        """
        self.broker_fqdn = broker_fqdn
        self.broker_ip_address = broker_ip_address
        self.broker_is_master = broker_is_master
        self.broker_port = broker_port
        self.broker_ssl_cert_thumbprint = broker_ssl_cert_thumbprint
        self.broker_virtual_host = broker_virtual_host
        VapiStruct.__init__(self)


BrokerProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.broker_properties', {
        'BrokerFqdn': type.OptionalType(type.StringType()),
        'BrokerIpAddress': type.OptionalType(type.StringType()),
        'BrokerIsMaster': type.OptionalType(type.StringType()),
        'BrokerPort': type.OptionalType(type.StringType()),
        'BrokerSslCertThumbprint': type.OptionalType(type.StringType()),
        'BrokerVirtualHost': type.OptionalType(type.StringType()),
    },
    BrokerProperties,
    False,
    None))



class BundleId(VapiStruct):
    """
    Identifier of the bundle

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'bundle_id': 'bundle_id',
                            }

    def __init__(self,
                 bundle_id=None,
                ):
        """
        :type  bundle_id: :class:`str` or ``None``
        :param bundle_id: Identifier of bundle upload
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.bundle_id = bundle_id
        VapiStruct.__init__(self)


BundleId._set_binding_type(type.StructType(
    'com.vmware.nsx.model.bundle_id', {
        'bundle_id': type.OptionalType(type.StringType()),
    },
    BundleId,
    False,
    None))



class BundleIds(VapiStruct):
    """
    Contains a list of bundle-ids

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'failed': 'failed',
                            'in_progress': 'in_progress',
                            'successful': 'successful',
                            }

    def __init__(self,
                 failed=None,
                 in_progress=None,
                 successful=None,
                ):
        """
        :type  failed: :class:`str` or ``None``
        :param failed: Id of a bundle whose upload was failed
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  in_progress: :class:`str` or ``None``
        :param in_progress: Id of a bundle whose upload is in-progress
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  successful: :class:`str` or ``None``
        :param successful: Id of a bundle whose upload is successful
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.failed = failed
        self.in_progress = in_progress
        self.successful = successful
        VapiStruct.__init__(self)


BundleIds._set_binding_type(type.StructType(
    'com.vmware.nsx.model.bundle_ids', {
        'failed': type.OptionalType(type.StringType()),
        'in_progress': type.OptionalType(type.StringType()),
        'successful': type.OptionalType(type.StringType()),
    },
    BundleIds,
    False,
    None))



class BundleUploadPermission(VapiStruct):
    """
    Describes wether bundle upload is allowed or not

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'reason': 'reason',
                            'upload_allowed': 'upload_allowed',
                            }

    def __init__(self,
                 reason=None,
                 upload_allowed=None,
                ):
        """
        :type  reason: :class:`str` or ``None``
        :param reason: Reason for not allowing upload
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  upload_allowed: :class:`bool` or ``None``
        :param upload_allowed: Flag indecation whether upload is allowed or not
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.reason = reason
        self.upload_allowed = upload_allowed
        VapiStruct.__init__(self)


BundleUploadPermission._set_binding_type(type.StructType(
    'com.vmware.nsx.model.bundle_upload_permission', {
        'reason': type.OptionalType(type.StringType()),
        'upload_allowed': type.OptionalType(type.BooleanType()),
    },
    BundleUploadPermission,
    False,
    None))



class BundleUploadStatus(VapiStruct):
    """
    Upload status of bundle uploaded from local or remote location

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATUS_UPLOADING = "UPLOADING"
    """


    """
    STATUS_VERIFYING = "VERIFYING"
    """


    """
    STATUS_SUCCESS = "SUCCESS"
    """


    """
    STATUS_FAILED = "FAILED"
    """


    """



    _canonical_to_pep_names = {
                            'bundle_name': 'bundle_name',
                            'detailed_status': 'detailed_status',
                            'percent': 'percent',
                            'status': 'status',
                            'url': 'url',
                            }

    def __init__(self,
                 bundle_name=None,
                 detailed_status=None,
                 percent=None,
                 status=None,
                 url=None,
                ):
        """
        :type  bundle_name: :class:`str` or ``None``
        :param bundle_name: Name of the uploaded bundle.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  detailed_status: :class:`str` or ``None``
        :param detailed_status: Detailed status of bundle upload
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  percent: :class:`float` or ``None``
        :param percent: Percent of bundle uploaded from remote location
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  status: :class:`str` or ``None``
        :param status: Possible values are: 
            
            * :attr:`BundleUploadStatus.STATUS_UPLOADING`
            * :attr:`BundleUploadStatus.STATUS_VERIFYING`
            * :attr:`BundleUploadStatus.STATUS_SUCCESS`
            * :attr:`BundleUploadStatus.STATUS_FAILED`
            
             Current status of bundle upload
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  url: :class:`str` or ``None``
        :param url: URL for uploading bundle
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.bundle_name = bundle_name
        self.detailed_status = detailed_status
        self.percent = percent
        self.status = status
        self.url = url
        VapiStruct.__init__(self)


BundleUploadStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.bundle_upload_status', {
        'bundle_name': type.OptionalType(type.StringType()),
        'detailed_status': type.OptionalType(type.StringType()),
        'percent': type.OptionalType(type.DoubleType()),
        'status': type.OptionalType(type.StringType()),
        'url': type.OptionalType(type.StringType()),
    },
    BundleUploadStatus,
    False,
    None))



class ByodServiceInstance(VapiStruct):
    """
    ByodServiceInstance is a custom instance to be used when NSX is not
    handling the lifecycles of appliance/s. User will manage their own
    appliance (BYOD) to connect with NSX.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "ByodServiceInstance"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    DEPLOYMENT_MODE_STAND_ALONE = "STAND_ALONE"
    """


    """
    DEPLOYMENT_MODE_ACTIVE_STANDBY = "ACTIVE_STANDBY"
    """


    """



    _canonical_to_pep_names = {
                            'deployment_mode': 'deployment_mode',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'on_failure_policy': 'on_failure_policy',
                            'service_id': 'service_id',
                            'transport_type': 'transport_type',
                            }

    def __init__(self,
                 deployment_mode=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='ByodServiceInstance',
                 tags=None,
                 on_failure_policy=None,
                 service_id=None,
                 transport_type=None,
                ):
        """
        :type  deployment_mode: :class:`str` or ``None``
        :param deployment_mode: Possible values are: 
            
            * :attr:`ByodServiceInstance.DEPLOYMENT_MODE_STAND_ALONE`
            * :attr:`ByodServiceInstance.DEPLOYMENT_MODE_ACTIVE_STANDBY`
            
            Deployment mode specifies where the partner appliance will be
            deployed in HA or non-HA i.e standalone mode.
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`BaseServiceInstance.RESOURCE_TYPE_SERVICEINSTANCE`
            * :attr:`BaseServiceInstance.RESOURCE_TYPE_BYODSERVICEINSTANCE`
            * :attr:`BaseServiceInstance.RESOURCE_TYPE_VIRTUALSERVICEINSTANCE`
            
            ServiceInstance is used when NSX handles the lifecyle of appliance.
            Deployment and appliance related all the information is necessary.
            ByodServiceInstance is a custom instance to be used when NSX is not
            handling the lifecycles of appliance/s. User will manage their own
            appliance (BYOD) to connect with NSX. VirtualServiceInstance is a a
            custom instance to be used when NSX is not handling the lifecycle
            of an appliance and when the user is not bringing their own
            appliance.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  on_failure_policy: :class:`str` or ``None``
        :param on_failure_policy: Possible values are: 
            
            * :attr:`BaseServiceInstance.ON_FAILURE_POLICY_ALLOW`
            * :attr:`BaseServiceInstance.ON_FAILURE_POLICY_BLOCK`
            
            Failure policy of the service instance - if it has to be different
            from the service. By default the service instance inherits the
            FailurePolicy of the service it belongs to.
        :type  service_id: :class:`str` or ``None``
        :param service_id: The Service to which the service instance is associated.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  transport_type: :class:`str` or ``None``
        :param transport_type: Possible values are: 
            
            * :attr:`BaseServiceInstance.TRANSPORT_TYPE_L2_BRIDGE`
            * :attr:`BaseServiceInstance.TRANSPORT_TYPE_L3_ROUTED`
            * :attr:`BaseServiceInstance.TRANSPORT_TYPE_NSH`
            * :attr:`BaseServiceInstance.TRANSPORT_TYPE_NA`
            
            Transport to be used by this service instance for deploying the
            Service-VM. This field is to be set Not Applicable(NA) if the
            service only caters to functionality EPP(Endpoint Protection).
        """
        self.deployment_mode = deployment_mode
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        self.on_failure_policy = on_failure_policy
        self.service_id = service_id
        self.transport_type = transport_type
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

ByodServiceInstance._set_binding_type(type.StructType(
    'com.vmware.nsx.model.byod_service_instance', {
        'deployment_mode': type.OptionalType(type.StringType()),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'on_failure_policy': type.OptionalType(type.StringType()),
        'service_id': type.OptionalType(type.StringType()),
        'transport_type': type.OptionalType(type.StringType()),
    },
    ByodServiceInstance,
    False,
    None))



class CCPUpgradeStatus(VapiStruct):
    """
    Status of CCP upgrade

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATUS_SUCCESS = "SUCCESS"
    """


    """
    STATUS_FAILED = "FAILED"
    """


    """
    STATUS_IN_PROGRESS = "IN_PROGRESS"
    """


    """
    STATUS_NOT_STARTED = "NOT_STARTED"
    """


    """
    STATUS_PAUSING = "PAUSING"
    """


    """
    STATUS_PAUSED = "PAUSED"
    """


    """



    _canonical_to_pep_names = {
                            'can_skip': 'can_skip',
                            'component_type': 'component_type',
                            'current_version_node_summary': 'current_version_node_summary',
                            'details': 'details',
                            'node_count_at_target_version': 'node_count_at_target_version',
                            'percent_complete': 'percent_complete',
                            'pre_upgrade_status': 'pre_upgrade_status',
                            'status': 'status',
                            'target_component_version': 'target_component_version',
                            }

    def __init__(self,
                 can_skip=None,
                 component_type=None,
                 current_version_node_summary=None,
                 details=None,
                 node_count_at_target_version=None,
                 percent_complete=None,
                 pre_upgrade_status=None,
                 status=None,
                 target_component_version=None,
                ):
        """
        :type  can_skip: :class:`bool` or ``None``
        :param can_skip: Can the upgrade of the remaining units in this component be skipped
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  component_type: :class:`str` or ``None``
        :param component_type: Component type for the upgrade status
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  current_version_node_summary: :class:`NodeSummaryList` or ``None``
        :param current_version_node_summary: Mapping of current versions of nodes and counts of nodes at the
            respective versions.
        :type  details: :class:`str` or ``None``
        :param details: Details about the upgrade status
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  node_count_at_target_version: :class:`long` or ``None``
        :param node_count_at_target_version: Number of nodes of the type and at the component version format:
            int32
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  percent_complete: :class:`float` or ``None``
        :param percent_complete: Indicator of upgrade progress in percentage
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  pre_upgrade_status: :class:`UpgradeChecksExecutionStatus` or ``None``
        :param pre_upgrade_status: Pre-upgrade status of the component-type
        :type  status: :class:`str` or ``None``
        :param status: Possible values are: 
            
            * :attr:`CCPUpgradeStatus.STATUS_SUCCESS`
            * :attr:`CCPUpgradeStatus.STATUS_FAILED`
            * :attr:`CCPUpgradeStatus.STATUS_IN_PROGRESS`
            * :attr:`CCPUpgradeStatus.STATUS_NOT_STARTED`
            * :attr:`CCPUpgradeStatus.STATUS_PAUSING`
            * :attr:`CCPUpgradeStatus.STATUS_PAUSED`
            
             Upgrade status of component
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  target_component_version: :class:`str` or ``None``
        :param target_component_version: Target component version
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.can_skip = can_skip
        self.component_type = component_type
        self.current_version_node_summary = current_version_node_summary
        self.details = details
        self.node_count_at_target_version = node_count_at_target_version
        self.percent_complete = percent_complete
        self.pre_upgrade_status = pre_upgrade_status
        self.status = status
        self.target_component_version = target_component_version
        VapiStruct.__init__(self)


CCPUpgradeStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.CCP_upgrade_status', {
        'can_skip': type.OptionalType(type.BooleanType()),
        'component_type': type.OptionalType(type.StringType()),
        'current_version_node_summary': type.OptionalType(type.ReferenceType(__name__, 'NodeSummaryList')),
        'details': type.OptionalType(type.StringType()),
        'node_count_at_target_version': type.OptionalType(type.IntegerType()),
        'percent_complete': type.OptionalType(type.DoubleType()),
        'pre_upgrade_status': type.OptionalType(type.ReferenceType(__name__, 'UpgradeChecksExecutionStatus')),
        'status': type.OptionalType(type.StringType()),
        'target_component_version': type.OptionalType(type.StringType()),
    },
    CCPUpgradeStatus,
    False,
    None))



class CPUReservation(VapiStruct):
    """
    Relative to the form factor pre-defined reservation value. We recommended
    that you use the predefined measures of CPU reservation shares to reduce
    the CPU reservation of a VM. Reservation shares are relative to the default
    form-factor value. Though absolute values for CPU reservation is supported,
    we advise to use this option with caution as incorrect or high reservation
    values could lead to deployment failure or lead to resource starvation for
    other VMs running on the same host.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    RESERVATION_IN_SHARES_EXTRA_HIGH_PRIORITY = "EXTRA_HIGH_PRIORITY"
    """


    """
    RESERVATION_IN_SHARES_HIGH_PRIORITY = "HIGH_PRIORITY"
    """


    """
    RESERVATION_IN_SHARES_NORMAL_PRIORITY = "NORMAL_PRIORITY"
    """


    """
    RESERVATION_IN_SHARES_LOW_PRIORITY = "LOW_PRIORITY"
    """


    """



    _canonical_to_pep_names = {
                            'reservation_in_mhz': 'reservation_in_mhz',
                            'reservation_in_shares': 'reservation_in_shares',
                            }

    def __init__(self,
                 reservation_in_mhz=None,
                 reservation_in_shares=None,
                ):
        """
        :type  reservation_in_mhz: :class:`long` or ``None``
        :param reservation_in_mhz: The CPU reservation in MHz is the guaranteed minimum amount of
            clock cycles that the vmkernel CPU scheduler will give the Edge VM
            in case of contention. If an Edge VM is not using its reserved
            resources, then other machines can use them thus preventing waste
            of CPU cycles on the physical host. Note: We recommend use of
            reservation_in_shares instead of this absolute configuration. When
            you specify this value, set reservation_in_shares to LOW_PRIORITY.
            format: int32
        :type  reservation_in_shares: :class:`str` or ``None``
        :param reservation_in_shares: Possible values are: 
            
            * :attr:`CPUReservation.RESERVATION_IN_SHARES_EXTRA_HIGH_PRIORITY`
            * :attr:`CPUReservation.RESERVATION_IN_SHARES_HIGH_PRIORITY`
            * :attr:`CPUReservation.RESERVATION_IN_SHARES_NORMAL_PRIORITY`
            * :attr:`CPUReservation.RESERVATION_IN_SHARES_LOW_PRIORITY`
            
            Shares specify the relative importance of a virtual machine on a
            given host. When you assign shares to a virtual machine, you always
            specify the priority for that virtual machine relative to other
            powered-on virtual machines on the same host. The default priority
            for shares is HIGH_PRIORITY.
        """
        self.reservation_in_mhz = reservation_in_mhz
        self.reservation_in_shares = reservation_in_shares
        VapiStruct.__init__(self)


CPUReservation._set_binding_type(type.StructType(
    'com.vmware.nsx.model.CPU_reservation', {
        'reservation_in_mhz': type.OptionalType(type.IntegerType()),
        'reservation_in_shares': type.OptionalType(type.StringType()),
    },
    CPUReservation,
    False,
    None))



class CallbackAuthenticationScheme(VapiStruct):
    """
    CallbackAuthenticationScheme describes how notification requests should
    authenticate to the server.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    SCHEME_NAME_BASIC_AUTH = "BASIC_AUTH"
    """


    """
    SCHEME_NAME_CERTIFICATE = "CERTIFICATE"
    """


    """



    _canonical_to_pep_names = {
                            'certificate_id': 'certificate_id',
                            'password': 'password',
                            'scheme_name': 'scheme_name',
                            'username': 'username',
                            }

    def __init__(self,
                 certificate_id=None,
                 password=None,
                 scheme_name=None,
                 username=None,
                ):
        """
        :type  certificate_id: :class:`str` or ``None``
        :param certificate_id: Certificate ID with a valid certificate and private key, procured
            from trust-management API.
        :type  password: :class:`str` or ``None``
        :param password: Password to use if scheme_name is BASIC_AUTH.
        :type  scheme_name: :class:`str` or ``None``
        :param scheme_name: Possible values are: 
            
            * :attr:`CallbackAuthenticationScheme.SCHEME_NAME_BASIC_AUTH`
            * :attr:`CallbackAuthenticationScheme.SCHEME_NAME_CERTIFICATE`
            
            Authentication scheme to use when making notification requests to
            the partner console. Specify one of BASIC_AUTH or CERTIFICATE.
        :type  username: :class:`str` or ``None``
        :param username: Username to use if scheme_name is BASIC_AUTH.
        """
        self.certificate_id = certificate_id
        self.password = password
        self.scheme_name = scheme_name
        self.username = username
        VapiStruct.__init__(self)


CallbackAuthenticationScheme._set_binding_type(type.StructType(
    'com.vmware.nsx.model.callback_authentication_scheme', {
        'certificate_id': type.OptionalType(type.StringType()),
        'password': type.OptionalType(type.StringType()),
        'scheme_name': type.OptionalType(type.StringType()),
        'username': type.OptionalType(type.StringType()),
    },
    CallbackAuthenticationScheme,
    False,
    None))



class CapacityDashboardUsage(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    SEVERITY_INFO = "INFO"
    """


    """
    SEVERITY_WARNING = "WARNING"
    """


    """
    SEVERITY_CRITICAL = "CRITICAL"
    """


    """
    SEVERITY_ERROR = "ERROR"
    """


    """
    USAGE_TYPE_LOGICAL_SWITCHES = "NUMBER_OF_LOGICAL_SWITCHES"
    """


    """
    USAGE_TYPE_PREPARED_HOSTS = "NUMBER_OF_PREPARED_HOSTS"
    """


    """
    USAGE_TYPE_NSGROUP = "NUMBER_OF_NSGROUP"
    """


    """
    USAGE_TYPE_VCENTER_CLUSTERS = "NUMBER_OF_VCENTER_CLUSTERS"
    """


    """
    USAGE_TYPE_GI_PROTECTED_HOSTS = "NUMBER_OF_GI_PROTECTED_HOSTS"
    """


    """
    USAGE_TYPE_GI_PROTECTED_VMS = "NUMBER_OF_GI_PROTECTED_VMS"
    """


    """
    USAGE_TYPE_DFW_RULES = "NUMBER_OF_DFW_RULES"
    """


    """
    USAGE_TYPE_DFW_SECTIONS = "NUMBER_OF_DFW_SECTIONS"
    """


    """
    USAGE_TYPE_L2_DFW_SECTIONS = "NUMBER_OF_L2_DFW_SECTIONS"
    """


    """
    USAGE_TYPE_L3_DFW_SECTIONS = "NUMBER_OF_L3_DFW_SECTIONS"
    """


    """
    USAGE_TYPE_L2_DFW_RULES = "NUMBER_OF_L2_DFW_RULES"
    """


    """
    USAGE_TYPE_L3_DFW_RULES = "NUMBER_OF_L3_DFW_RULES"
    """


    """
    USAGE_TYPE_L3_EDGE_SECTIONS = "NUMBER_OF_L3_EDGE_SECTIONS"
    """


    """
    USAGE_TYPE_L3_EDGE_RULES = "NUMBER_OF_L3_EDGE_RULES"
    """


    """
    USAGE_TYPE_L3_BRIDGEPORT_SECTIONS = "NUMBER_OF_L3_BRIDGEPORT_SECTIONS"
    """


    """
    USAGE_TYPE_L3_BRIDGEPORT_RULES = "NUMBER_OF_L3_BRIDGEPORT_RULES"
    """


    """
    USAGE_TYPE_IPSETS = "NUMBER_OF_IPSETS"
    """


    """
    USAGE_TYPE_GROUPS_BASED_ON_IP_SETS = "NUMBER_OF_GROUPS_BASED_ON_IP_SETS"
    """


    """
    USAGE_TYPE_LOGICAL_PORTS = "NUMBER_OF_LOGICAL_PORTS"
    """


    """
    USAGE_TYPE_EDGE_CLUSTERS = "NUMBER_OF_EDGE_CLUSTERS"
    """


    """
    USAGE_TYPE_EDGE_NODES = "NUMBER_OF_EDGE_NODES"
    """


    """
    USAGE_TYPE_TIER0_ROUTERS = "NUMBER_OF_TIER0_ROUTERS"
    """


    """
    USAGE_TYPE_TIER1_ROUTERS = "NUMBER_OF_TIER1_ROUTERS"
    """


    """
    USAGE_TYPE_PREFIX_LIST = "NUMBER_OF_PREFIX_LIST"
    """


    """
    USAGE_TYPE_NAT_RULES = "NUMBER_OF_NAT_RULES"
    """


    """
    USAGE_TYPE_TIER1_WITH_NAT_RULE = "NUMBER_OF_TIER1_WITH_NAT_RULE"
    """


    """
    USAGE_TYPE_DHCP_SERVERS = "NUMBER_OF_DHCP_SERVERS"
    """


    """
    USAGE_TYPE_DHCP_IP_POOLS = "NUMBER_OF_DHCP_IP_POOLS"
    """


    """
    USAGE_TYPE_ACTIVE_DIRECTORY_GROUPS = "NUMBER_OF_ACTIVE_DIRECTORY_GROUPS"
    """


    """
    USAGE_TYPE_ACTIVE_DIRECTORY_DOMAINS = "NUMBER_OF_ACTIVE_DIRECTORY_DOMAINS"
    """


    """
    USAGE_TYPE_FIREWALL_SECTIONS = "NUMBER_OF_FIREWALL_SECTIONS"
    """


    """
    USAGE_TYPE_FIREWALL_RULES = "NUMBER_OF_FIREWALL_RULES"
    """


    """



    _canonical_to_pep_names = {
                            'current_usage_count': 'current_usage_count',
                            'current_usage_percentage': 'current_usage_percentage',
                            'display_name': 'display_name',
                            'max_supported_count': 'max_supported_count',
                            'max_threshold_percentage': 'max_threshold_percentage',
                            'min_threshold_percentage': 'min_threshold_percentage',
                            'severity': 'severity',
                            'usage_type': 'usage_type',
                            }

    def __init__(self,
                 current_usage_count=None,
                 current_usage_percentage=None,
                 display_name=None,
                 max_supported_count=None,
                 max_threshold_percentage=None,
                 min_threshold_percentage=None,
                 severity=None,
                 usage_type=None,
                ):
        """
        :type  current_usage_count: :class:`long` or ``None``
        :param current_usage_count: Indicate the current usage count of object type. format: int64
        :type  current_usage_percentage: :class:`float` or ``None``
        :param current_usage_percentage: Current usage percentage for object type
        :type  display_name: :class:`str` or ``None``
        :param display_name: Display name for NSX object type.
        :type  max_supported_count: :class:`long` or ``None``
        :param max_supported_count: This is the maximum supported count for object type in
            consideration. format: int64
        :type  max_threshold_percentage: :class:`float` or ``None``
        :param max_threshold_percentage: This indicates the maximum threshold percentage for object type.
        :type  min_threshold_percentage: :class:`float` or ``None``
        :param min_threshold_percentage: This indicates the minimum threshold percentage for object type.
        :type  severity: :class:`str` or ``None``
        :param severity: Possible values are: 
            
            * :attr:`CapacityDashboardUsage.SEVERITY_INFO`
            * :attr:`CapacityDashboardUsage.SEVERITY_WARNING`
            * :attr:`CapacityDashboardUsage.SEVERITY_CRITICAL`
            * :attr:`CapacityDashboardUsage.SEVERITY_ERROR`
            
             Severity calculated from percentage usage
        :type  usage_type: :class:`str` or ``None``
        :param usage_type: Possible values are: 
            
            * :attr:`CapacityDashboardUsage.USAGE_TYPE_LOGICAL_SWITCHES`
            * :attr:`CapacityDashboardUsage.USAGE_TYPE_PREPARED_HOSTS`
            * :attr:`CapacityDashboardUsage.USAGE_TYPE_NSGROUP`
            * :attr:`CapacityDashboardUsage.USAGE_TYPE_VCENTER_CLUSTERS`
            * :attr:`CapacityDashboardUsage.USAGE_TYPE_GI_PROTECTED_HOSTS`
            * :attr:`CapacityDashboardUsage.USAGE_TYPE_GI_PROTECTED_VMS`
            * :attr:`CapacityDashboardUsage.USAGE_TYPE_DFW_RULES`
            * :attr:`CapacityDashboardUsage.USAGE_TYPE_DFW_SECTIONS`
            * :attr:`CapacityDashboardUsage.USAGE_TYPE_L2_DFW_SECTIONS`
            * :attr:`CapacityDashboardUsage.USAGE_TYPE_L3_DFW_SECTIONS`
            * :attr:`CapacityDashboardUsage.USAGE_TYPE_L2_DFW_RULES`
            * :attr:`CapacityDashboardUsage.USAGE_TYPE_L3_DFW_RULES`
            * :attr:`CapacityDashboardUsage.USAGE_TYPE_L3_EDGE_SECTIONS`
            * :attr:`CapacityDashboardUsage.USAGE_TYPE_L3_EDGE_RULES`
            * :attr:`CapacityDashboardUsage.USAGE_TYPE_L3_BRIDGEPORT_SECTIONS`
            * :attr:`CapacityDashboardUsage.USAGE_TYPE_L3_BRIDGEPORT_RULES`
            * :attr:`CapacityDashboardUsage.USAGE_TYPE_IPSETS`
            * :attr:`CapacityDashboardUsage.USAGE_TYPE_GROUPS_BASED_ON_IP_SETS`
            * :attr:`CapacityDashboardUsage.USAGE_TYPE_LOGICAL_PORTS`
            * :attr:`CapacityDashboardUsage.USAGE_TYPE_EDGE_CLUSTERS`
            * :attr:`CapacityDashboardUsage.USAGE_TYPE_EDGE_NODES`
            * :attr:`CapacityDashboardUsage.USAGE_TYPE_TIER0_ROUTERS`
            * :attr:`CapacityDashboardUsage.USAGE_TYPE_TIER1_ROUTERS`
            * :attr:`CapacityDashboardUsage.USAGE_TYPE_PREFIX_LIST`
            * :attr:`CapacityDashboardUsage.USAGE_TYPE_NAT_RULES`
            * :attr:`CapacityDashboardUsage.USAGE_TYPE_TIER1_WITH_NAT_RULE`
            * :attr:`CapacityDashboardUsage.USAGE_TYPE_DHCP_SERVERS`
            * :attr:`CapacityDashboardUsage.USAGE_TYPE_DHCP_IP_POOLS`
            * :attr:`CapacityDashboardUsage.USAGE_TYPE_ACTIVE_DIRECTORY_GROUPS`
            *
              :attr:`CapacityDashboardUsage.USAGE_TYPE_ACTIVE_DIRECTORY_DOMAINS`
            * :attr:`CapacityDashboardUsage.USAGE_TYPE_FIREWALL_SECTIONS`
            * :attr:`CapacityDashboardUsage.USAGE_TYPE_FIREWALL_RULES`
            
             Indicate the object type for which usage is calculated.
        """
        self.current_usage_count = current_usage_count
        self.current_usage_percentage = current_usage_percentage
        self.display_name = display_name
        self.max_supported_count = max_supported_count
        self.max_threshold_percentage = max_threshold_percentage
        self.min_threshold_percentage = min_threshold_percentage
        self.severity = severity
        self.usage_type = usage_type
        VapiStruct.__init__(self)


CapacityDashboardUsage._set_binding_type(type.StructType(
    'com.vmware.nsx.model.capacity_dashboard_usage', {
        'current_usage_count': type.OptionalType(type.IntegerType()),
        'current_usage_percentage': type.OptionalType(type.DoubleType()),
        'display_name': type.OptionalType(type.StringType()),
        'max_supported_count': type.OptionalType(type.IntegerType()),
        'max_threshold_percentage': type.OptionalType(type.DoubleType()),
        'min_threshold_percentage': type.OptionalType(type.DoubleType()),
        'severity': type.OptionalType(type.StringType()),
        'usage_type': type.OptionalType(type.StringType()),
    },
    CapacityDashboardUsage,
    False,
    None))



class CapacityThreshold(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    THRESHOLD_TYPE_NUMBER_OF_LOGICAL_SWITCHES = "NUMBER_OF_LOGICAL_SWITCHES"
    """


    """
    THRESHOLD_TYPE_NUMBER_OF_PREPARED_HOSTS = "NUMBER_OF_PREPARED_HOSTS"
    """


    """
    THRESHOLD_TYPE_NUMBER_OF_NSGROUP = "NUMBER_OF_NSGROUP"
    """


    """
    THRESHOLD_TYPE_NUMBER_OF_VCENTER_CLUSTERS = "NUMBER_OF_VCENTER_CLUSTERS"
    """


    """
    THRESHOLD_TYPE_NUMBER_OF_GI_PROTECTED_HOSTS = "NUMBER_OF_GI_PROTECTED_HOSTS"
    """


    """
    THRESHOLD_TYPE_NUMBER_OF_GI_PROTECTED_VMS = "NUMBER_OF_GI_PROTECTED_VMS"
    """


    """
    THRESHOLD_TYPE_NUMBER_OF_DFW_RULES = "NUMBER_OF_DFW_RULES"
    """


    """
    THRESHOLD_TYPE_NUMBER_OF_DFW_SECTIONS = "NUMBER_OF_DFW_SECTIONS"
    """


    """
    THRESHOLD_TYPE_NUMBER_OF_IPSETS = "NUMBER_OF_IPSETS"
    """


    """
    THRESHOLD_TYPE_NUMBER_OF_GROUPS_BASED_ON_IP_SETS = "NUMBER_OF_GROUPS_BASED_ON_IP_SETS"
    """


    """
    THRESHOLD_TYPE_NUMBER_OF_LOGICAL_PORTS = "NUMBER_OF_LOGICAL_PORTS"
    """


    """
    THRESHOLD_TYPE_NUMBER_OF_EDGE_CLUSTERS = "NUMBER_OF_EDGE_CLUSTERS"
    """


    """
    THRESHOLD_TYPE_NUMBER_OF_EDGE_NODES = "NUMBER_OF_EDGE_NODES"
    """


    """
    THRESHOLD_TYPE_NUMBER_OF_TIER0_ROUTERS = "NUMBER_OF_TIER0_ROUTERS"
    """


    """
    THRESHOLD_TYPE_NUMBER_OF_TIER1_ROUTERS = "NUMBER_OF_TIER1_ROUTERS"
    """


    """
    THRESHOLD_TYPE_NUMBER_OF_PREFIX_LIST = "NUMBER_OF_PREFIX_LIST"
    """


    """
    THRESHOLD_TYPE_NUMBER_OF_NAT_RULES = "NUMBER_OF_NAT_RULES"
    """


    """
    THRESHOLD_TYPE_NUMBER_OF_TIER1_WITH_NAT_RULE = "NUMBER_OF_TIER1_WITH_NAT_RULE"
    """


    """
    THRESHOLD_TYPE_NUMBER_OF_DHCP_SERVERS = "NUMBER_OF_DHCP_SERVERS"
    """


    """
    THRESHOLD_TYPE_NUMBER_OF_DHCP_IP_POOLS = "NUMBER_OF_DHCP_IP_POOLS"
    """


    """
    THRESHOLD_TYPE_NUMBER_OF_ACTIVE_DIRECTORY_GROUPS = "NUMBER_OF_ACTIVE_DIRECTORY_GROUPS"
    """


    """
    THRESHOLD_TYPE_NUMBER_OF_ACTIVE_DIRECTORY_DOMAINS = "NUMBER_OF_ACTIVE_DIRECTORY_DOMAINS"
    """


    """
    THRESHOLD_TYPE_NUMBER_OF_FIREWALL_SECTIONS = "NUMBER_OF_FIREWALL_SECTIONS"
    """


    """
    THRESHOLD_TYPE_NUMBER_OF_FIREWALL_RULES = "NUMBER_OF_FIREWALL_RULES"
    """


    """
    THRESHOLD_TYPE_GLOBAL_DEFAULT = "GLOBAL_DEFAULT"
    """


    """



    _canonical_to_pep_names = {
                            'max_threshold_percentage': 'max_threshold_percentage',
                            'min_threshold_percentage': 'min_threshold_percentage',
                            'threshold_type': 'threshold_type',
                            }

    def __init__(self,
                 max_threshold_percentage=None,
                 min_threshold_percentage=None,
                 threshold_type=None,
                ):
        """
        :type  max_threshold_percentage: :class:`float` or ``None``
        :param max_threshold_percentage: Set the maximum threshold percentage. Specify a value between 0 and
            100. Usage percentage above this value is tagged as critical.
        :type  min_threshold_percentage: :class:`float` or ``None``
        :param min_threshold_percentage: Set the minimum threshold percentage. Specify a value between 0 and
            100. Usage percentage above this value is tagged as warning.
        :type  threshold_type: :class:`str` or ``None``
        :param threshold_type: Possible values are: 
            
            *
              :attr:`CapacityThreshold.THRESHOLD_TYPE_NUMBER_OF_LOGICAL_SWITCHES`
            * :attr:`CapacityThreshold.THRESHOLD_TYPE_NUMBER_OF_PREPARED_HOSTS`
            * :attr:`CapacityThreshold.THRESHOLD_TYPE_NUMBER_OF_NSGROUP`
            *
              :attr:`CapacityThreshold.THRESHOLD_TYPE_NUMBER_OF_VCENTER_CLUSTERS`
            *
              :attr:`CapacityThreshold.THRESHOLD_TYPE_NUMBER_OF_GI_PROTECTED_HOSTS`
            *
              :attr:`CapacityThreshold.THRESHOLD_TYPE_NUMBER_OF_GI_PROTECTED_VMS`
            * :attr:`CapacityThreshold.THRESHOLD_TYPE_NUMBER_OF_DFW_RULES`
            * :attr:`CapacityThreshold.THRESHOLD_TYPE_NUMBER_OF_DFW_SECTIONS`
            * :attr:`CapacityThreshold.THRESHOLD_TYPE_NUMBER_OF_IPSETS`
            *
              :attr:`CapacityThreshold.THRESHOLD_TYPE_NUMBER_OF_GROUPS_BASED_ON_IP_SETS`
            * :attr:`CapacityThreshold.THRESHOLD_TYPE_NUMBER_OF_LOGICAL_PORTS`
            * :attr:`CapacityThreshold.THRESHOLD_TYPE_NUMBER_OF_EDGE_CLUSTERS`
            * :attr:`CapacityThreshold.THRESHOLD_TYPE_NUMBER_OF_EDGE_NODES`
            * :attr:`CapacityThreshold.THRESHOLD_TYPE_NUMBER_OF_TIER0_ROUTERS`
            * :attr:`CapacityThreshold.THRESHOLD_TYPE_NUMBER_OF_TIER1_ROUTERS`
            * :attr:`CapacityThreshold.THRESHOLD_TYPE_NUMBER_OF_PREFIX_LIST`
            * :attr:`CapacityThreshold.THRESHOLD_TYPE_NUMBER_OF_NAT_RULES`
            *
              :attr:`CapacityThreshold.THRESHOLD_TYPE_NUMBER_OF_TIER1_WITH_NAT_RULE`
            * :attr:`CapacityThreshold.THRESHOLD_TYPE_NUMBER_OF_DHCP_SERVERS`
            * :attr:`CapacityThreshold.THRESHOLD_TYPE_NUMBER_OF_DHCP_IP_POOLS`
            *
              :attr:`CapacityThreshold.THRESHOLD_TYPE_NUMBER_OF_ACTIVE_DIRECTORY_GROUPS`
            *
              :attr:`CapacityThreshold.THRESHOLD_TYPE_NUMBER_OF_ACTIVE_DIRECTORY_DOMAINS`
            *
              :attr:`CapacityThreshold.THRESHOLD_TYPE_NUMBER_OF_FIREWALL_SECTIONS`
            * :attr:`CapacityThreshold.THRESHOLD_TYPE_NUMBER_OF_FIREWALL_RULES`
            * :attr:`CapacityThreshold.THRESHOLD_TYPE_GLOBAL_DEFAULT`
            
             Indicate the object type for which threshold is to be set.
        """
        self.max_threshold_percentage = max_threshold_percentage
        self.min_threshold_percentage = min_threshold_percentage
        self.threshold_type = threshold_type
        VapiStruct.__init__(self)


CapacityThreshold._set_binding_type(type.StructType(
    'com.vmware.nsx.model.capacity_threshold', {
        'max_threshold_percentage': type.OptionalType(type.DoubleType()),
        'min_threshold_percentage': type.OptionalType(type.DoubleType()),
        'threshold_type': type.OptionalType(type.StringType()),
    },
    CapacityThreshold,
    False,
    None))



class CapacityThresholdList(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'capacity_thresholds': 'capacity_thresholds',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 capacity_thresholds=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  capacity_thresholds: :class:`list` of :class:`CapacityThreshold` or ``None``
        :param capacity_thresholds: List of capacity thresholds for NSX Objects
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.capacity_thresholds = capacity_thresholds
        VapiStruct.__init__(self)


CapacityThresholdList._set_binding_type(type.StructType(
    'com.vmware.nsx.model.capacity_threshold_list', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'capacity_thresholds': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'CapacityThreshold'))),
    },
    CapacityThresholdList,
    False,
    None))



class CapacityUsage(VapiStruct):
    """
    usage of each capacity type ex. vm, cpu

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'capacity_type': 'capacity_type',
                            'usage_count': 'usage_count',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 capacity_type=None,
                 usage_count=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  capacity_type: :class:`str` or ``None``
        :param capacity_type: type of the capacity field
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  usage_count: :class:`long` or ``None``
        :param usage_count: count of number of items of capacity_type format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.capacity_type = capacity_type
        self.usage_count = usage_count
        VapiStruct.__init__(self)


CapacityUsage._set_binding_type(type.StructType(
    'com.vmware.nsx.model.capacity_usage', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'capacity_type': type.OptionalType(type.StringType()),
        'usage_count': type.OptionalType(type.IntegerType()),
    },
    CapacityUsage,
    False,
    None))



class CapacityUsageMetaInfo(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'last_updated_timestamp': 'last_updated_timestamp',
                            'max_global_threshold_percentage': 'max_global_threshold_percentage',
                            'min_global_threshold_percentage': 'min_global_threshold_percentage',
                            }

    def __init__(self,
                 last_updated_timestamp=None,
                 max_global_threshold_percentage=None,
                 min_global_threshold_percentage=None,
                ):
        """
        :type  last_updated_timestamp: :class:`long` or ``None``
        :param last_updated_timestamp: Timestamp at which capacity usage was last calculated format: int64
        :type  max_global_threshold_percentage: :class:`float` or ``None``
        :param max_global_threshold_percentage: Indicates the maximum global threshold percentage
        :type  min_global_threshold_percentage: :class:`float` or ``None``
        :param min_global_threshold_percentage: Indicates the minimum global threshold percentage
        """
        self.last_updated_timestamp = last_updated_timestamp
        self.max_global_threshold_percentage = max_global_threshold_percentage
        self.min_global_threshold_percentage = min_global_threshold_percentage
        VapiStruct.__init__(self)


CapacityUsageMetaInfo._set_binding_type(type.StructType(
    'com.vmware.nsx.model.capacity_usage_meta_info', {
        'last_updated_timestamp': type.OptionalType(type.IntegerType()),
        'max_global_threshold_percentage': type.OptionalType(type.DoubleType()),
        'min_global_threshold_percentage': type.OptionalType(type.DoubleType()),
    },
    CapacityUsageMetaInfo,
    False,
    None))



class CapacityUsageResponse(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'capacity_usage': 'capacity_usage',
                            'meta_info': 'meta_info',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 capacity_usage=None,
                 meta_info=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  capacity_usage: :class:`list` of :class:`CapacityDashboardUsage` or ``None``
        :param capacity_usage: List of capacity usage for NSX Objects
        :type  meta_info: :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param meta_info: Meta data for capacity usage statistics
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.capacity_usage = capacity_usage
        self.meta_info = meta_info
        VapiStruct.__init__(self)


CapacityUsageResponse._set_binding_type(type.StructType(
    'com.vmware.nsx.model.capacity_usage_response', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'capacity_usage': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'CapacityDashboardUsage'))),
        'meta_info': type.OptionalType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct)),
    },
    CapacityUsageResponse,
    False,
    None))



class CentralConfigProperties(VapiStruct):
    """
    Central Config properties

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'local_override': 'local_override',
                            }

    def __init__(self,
                 local_override=None,
                ):
        """
        :type  local_override: :class:`bool` or ``None``
        :param local_override: Override Central Config
        """
        self.local_override = local_override
        VapiStruct.__init__(self)


CentralConfigProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.central_config_properties', {
        'local_override': type.OptionalType(type.BooleanType()),
    },
    CentralConfigProperties,
    False,
    None))



class CentralNodeConfigProfile(VapiStruct):
    """
    Central Node Config profile for NSX nodes. This set of properties will be
    pushed to NSX Manager and Edge nodes. SNMP properties will be pushed to KVM
    Hypervisors in addition to Manager and Edge nodes.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'ntp': 'ntp',
                            'snmp': 'snmp',
                            'syslog': 'syslog',
                            'timezone': 'timezone',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 ntp=None,
                 snmp=None,
                 syslog=None,
                 timezone=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  ntp: :class:`NtpProperties` or ``None``
        :param ntp: NTP service properties for NSX nodes.
        :type  snmp: :class:`SnmpProperties` or ``None``
        :param snmp: SNMP service properties for NSX nodes.
        :type  syslog: :class:`SyslogProperties` or ``None``
        :param syslog: Syslog service properties for NSX nodes.
        :type  timezone: :class:`str` or ``None``
        :param timezone: Timezone to be set for NSX nodes. Only timezone strings listed in
            the Time Zone database (https://www.iana.org/time-zones) are
            allowed.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.ntp = ntp
        self.snmp = snmp
        self.syslog = syslog
        self.timezone = timezone
        VapiStruct.__init__(self)


CentralNodeConfigProfile._set_binding_type(type.StructType(
    'com.vmware.nsx.model.central_node_config_profile', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'ntp': type.OptionalType(type.ReferenceType(__name__, 'NtpProperties')),
        'snmp': type.OptionalType(type.ReferenceType(__name__, 'SnmpProperties')),
        'syslog': type.OptionalType(type.ReferenceType(__name__, 'SyslogProperties')),
        'timezone': type.OptionalType(type.StringType()),
    },
    CentralNodeConfigProfile,
    False,
    None))



class CentralNodeConfigProfileListResult(VapiStruct):
    """
    Paged collection of Central Node Config profiles.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`CentralNodeConfigProfile` or ``None``
        :param results: Central Node Config profiles
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


CentralNodeConfigProfileListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.central_node_config_profile_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'CentralNodeConfigProfile'))),
    },
    CentralNodeConfigProfileListResult,
    False,
    None))



class Certificate(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'details': 'details',
                            'pem_encoded': 'pem_encoded',
                            'used_by': 'used_by',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 details=None,
                 pem_encoded=None,
                 used_by=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  details: :class:`list` of :class:`X509Certificate` or ``None``
        :param details: List of X509Certificates.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  pem_encoded: :class:`str` or ``None``
        :param pem_encoded: PEM encoded certificate data.
        :type  used_by: :class:`list` of :class:`NodeIdServicesMap` or ``None``
        :param used_by: List of node IDs with services, that are using this certificate.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.details = details
        self.pem_encoded = pem_encoded
        self.used_by = used_by
        VapiStruct.__init__(self)


Certificate._set_binding_type(type.StructType(
    'com.vmware.nsx.model.certificate', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'details': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'X509Certificate'))),
        'pem_encoded': type.OptionalType(type.StringType()),
        'used_by': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NodeIdServicesMap'))),
    },
    Certificate,
    False,
    None))



class CertificateCheckingStatus(VapiStruct):
    """
    Result of checking a certificate

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATUS_OK = "OK"
    """


    """
    STATUS_CRL_NOT_READY = "CRL_NOT_READY"
    """


    """
    STATUS_REJECTED = "REJECTED"
    """


    """
    STATUS_ERROR = "ERROR"
    """


    """



    _canonical_to_pep_names = {
                            'error_message': 'error_message',
                            'status': 'status',
                            }

    def __init__(self,
                 error_message=None,
                 status=None,
                ):
        """
        :type  error_message: :class:`str` or ``None``
        :param error_message: Error message when checking the certificate.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  status: :class:`str` or ``None``
        :param status: Possible values are: 
            
            * :attr:`CertificateCheckingStatus.STATUS_OK`
            * :attr:`CertificateCheckingStatus.STATUS_CRL_NOT_READY`
            * :attr:`CertificateCheckingStatus.STATUS_REJECTED`
            * :attr:`CertificateCheckingStatus.STATUS_ERROR`
            
             Status of the checked certificate.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.error_message = error_message
        self.status = status
        VapiStruct.__init__(self)


CertificateCheckingStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.certificate_checking_status', {
        'error_message': type.OptionalType(type.StringType()),
        'status': type.OptionalType(type.StringType()),
    },
    CertificateCheckingStatus,
    False,
    None))



class CertificateKeyPair(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'certificate': 'certificate',
                            'rsa_private_key': 'rsa_private_key',
                            }

    def __init__(self,
                 certificate=None,
                 rsa_private_key=None,
                ):
        """
        :type  certificate: :class:`SecurityCertificate` or ``None``
        :param certificate: 
        :type  rsa_private_key: :class:`str` or ``None``
        :param rsa_private_key: The private key must include the enclosing \"-----BEGIN RSA PRIVATE
            KEY-----\" and \"-----END RSA PRIVATE KEY-----\". An empty string
            is returned in read responses.
        """
        self.certificate = certificate
        self.rsa_private_key = rsa_private_key
        VapiStruct.__init__(self)


CertificateKeyPair._set_binding_type(type.StructType(
    'com.vmware.nsx.model.certificate_key_pair', {
        'certificate': type.OptionalType(type.ReferenceType(__name__, 'SecurityCertificate')),
        'rsa_private_key': type.OptionalType(type.StringType()),
    },
    CertificateKeyPair,
    False,
    None))



class CertificateList(VapiStruct):
    """
    Certificate queries result

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`Certificate` or ``None``
        :param results: Certificate list.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


CertificateList._set_binding_type(type.StructType(
    'com.vmware.nsx.model.certificate_list', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Certificate'))),
    },
    CertificateList,
    False,
    None))



class CipherSuite(VapiStruct):
    """
    TLS cipher suite

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'enabled': 'enabled',
                            'name': 'name',
                            }

    def __init__(self,
                 enabled=None,
                 name=None,
                ):
        """
        :type  enabled: :class:`bool` or ``None``
        :param enabled: Enable status for this cipher suite
        :type  name: :class:`str` or ``None``
        :param name: Name of the TLS cipher suite
        """
        self.enabled = enabled
        self.name = name
        VapiStruct.__init__(self)


CipherSuite._set_binding_type(type.StructType(
    'com.vmware.nsx.model.cipher_suite', {
        'enabled': type.OptionalType(type.BooleanType()),
        'name': type.OptionalType(type.StringType()),
    },
    CipherSuite,
    False,
    None))



class ClasslessStaticRoute(VapiStruct):
    """
    DHCP classless static route option.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'network': 'network',
                            'next_hop': 'next_hop',
                            }

    def __init__(self,
                 network=None,
                 next_hop=None,
                ):
        """
        :type  network: :class:`str` or ``None``
        :param network: Destination network in CIDR format. format:
            address-or-block-or-range
        :type  next_hop: :class:`str` or ``None``
        :param next_hop: IP address of next hop of the route. format: ip
        """
        self.network = network
        self.next_hop = next_hop
        VapiStruct.__init__(self)


ClasslessStaticRoute._set_binding_type(type.StructType(
    'com.vmware.nsx.model.classless_static_route', {
        'network': type.OptionalType(type.StringType()),
        'next_hop': type.OptionalType(type.StringType()),
    },
    ClasslessStaticRoute,
    False,
    None))



class ClientSslProfileBinding(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    CLIENT_AUTH_REQUIRED = "REQUIRED"
    """


    """
    CLIENT_AUTH_IGNORE = "IGNORE"
    """


    """



    _canonical_to_pep_names = {
                            'certificate_chain_depth': 'certificate_chain_depth',
                            'client_auth': 'client_auth',
                            'client_auth_ca_ids': 'client_auth_ca_ids',
                            'client_auth_crl_ids': 'client_auth_crl_ids',
                            'default_certificate_id': 'default_certificate_id',
                            'sni_certificate_ids': 'sni_certificate_ids',
                            'ssl_profile_id': 'ssl_profile_id',
                            }

    def __init__(self,
                 certificate_chain_depth=None,
                 client_auth=None,
                 client_auth_ca_ids=None,
                 client_auth_crl_ids=None,
                 default_certificate_id=None,
                 sni_certificate_ids=None,
                 ssl_profile_id=None,
                ):
        """
        :type  certificate_chain_depth: :class:`long` or ``None``
        :param certificate_chain_depth: authentication depth is used to set the verification depth in the
            client certificates chain. format: int64
        :type  client_auth: :class:`str` or ``None``
        :param client_auth: Possible values are: 
            
            * :attr:`ClientSslProfileBinding.CLIENT_AUTH_REQUIRED`
            * :attr:`ClientSslProfileBinding.CLIENT_AUTH_IGNORE`
            
             client authentication mode
        :type  client_auth_ca_ids: :class:`list` of :class:`str` or ``None``
        :param client_auth_ca_ids: If client auth type is REQUIRED, client certificate must be signed
            by one of the trusted Certificate Authorities (CAs), also referred
            to as root CAs, whose self signed certificates are specified.
        :type  client_auth_crl_ids: :class:`list` of :class:`str` or ``None``
        :param client_auth_crl_ids: A Certificate Revocation List (CRL) can be specified in the
            client-side SSL profile binding to disallow compromised client
            certificates.
        :type  default_certificate_id: :class:`str` or ``None``
        :param default_certificate_id: A default certificate should be specified which will be used if the
            server does not host multiple hostnames on the same IP address or
            if the client does not support SNI extension.
        :type  sni_certificate_ids: :class:`list` of :class:`str` or ``None``
        :param sni_certificate_ids: Client-side SSL profile binding allows multiple certificates, for
            different hostnames, to be bound to the same virtual server.
        :type  ssl_profile_id: :class:`str` or ``None``
        :param ssl_profile_id: Client SSL profile defines reusable, application-independent client
            side SSL properties.
        """
        self.certificate_chain_depth = certificate_chain_depth
        self.client_auth = client_auth
        self.client_auth_ca_ids = client_auth_ca_ids
        self.client_auth_crl_ids = client_auth_crl_ids
        self.default_certificate_id = default_certificate_id
        self.sni_certificate_ids = sni_certificate_ids
        self.ssl_profile_id = ssl_profile_id
        VapiStruct.__init__(self)


ClientSslProfileBinding._set_binding_type(type.StructType(
    'com.vmware.nsx.model.client_ssl_profile_binding', {
        'certificate_chain_depth': type.OptionalType(type.IntegerType()),
        'client_auth': type.OptionalType(type.StringType()),
        'client_auth_ca_ids': type.OptionalType(type.ListType(type.StringType())),
        'client_auth_crl_ids': type.OptionalType(type.ListType(type.StringType())),
        'default_certificate_id': type.OptionalType(type.StringType()),
        'sni_certificate_ids': type.OptionalType(type.ListType(type.StringType())),
        'ssl_profile_id': type.OptionalType(type.StringType()),
    },
    ClientSslProfileBinding,
    False,
    None))



class ClientTypeCollectionConfiguration(VapiStruct):
    """
    HPM client data collection configuration

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    CLIENT_TYPE_HYPERVISOR = "HYPERVISOR"
    """


    """
    CLIENT_TYPE_EDGE = "EDGE"
    """


    """
    CLIENT_TYPE_CONTROL_PLANE = "CONTROL_PLANE"
    """


    """
    CLIENT_TYPE_CONTROL_PLANE_PLATFORM = "CONTROL_PLANE_PLATFORM"
    """


    """
    CLIENT_TYPE_MANAGEMENT_PLANE = "MANAGEMENT_PLANE"
    """


    """
    CLIENT_TYPE_MANAGEMENT_PLANE_PLATFORM = "MANAGEMENT_PLANE_PLATFORM"
    """


    """



    _canonical_to_pep_names = {
                            'client_type': 'client_type',
                            'data_type_configurations': 'data_type_configurations',
                            }

    def __init__(self,
                 client_type=None,
                 data_type_configurations=None,
                ):
        """
        :type  client_type: :class:`str` or ``None``
        :param client_type: Possible values are: 
            
            * :attr:`ClientTypeCollectionConfiguration.CLIENT_TYPE_HYPERVISOR`
            * :attr:`ClientTypeCollectionConfiguration.CLIENT_TYPE_EDGE`
            *
              :attr:`ClientTypeCollectionConfiguration.CLIENT_TYPE_CONTROL_PLANE`
            *
              :attr:`ClientTypeCollectionConfiguration.CLIENT_TYPE_CONTROL_PLANE_PLATFORM`
            *
              :attr:`ClientTypeCollectionConfiguration.CLIENT_TYPE_MANAGEMENT_PLANE`
            *
              :attr:`ClientTypeCollectionConfiguration.CLIENT_TYPE_MANAGEMENT_PLANE_PLATFORM`
            
            The client type for which this data collection frequency setting
            applies
        :type  data_type_configurations: :class:`list` of :class:`DataTypeCollectionConfiguration` or ``None``
        :param data_type_configurations: The set of data collection type configurations, one for each data
            collection type
        """
        self.client_type = client_type
        self.data_type_configurations = data_type_configurations
        VapiStruct.__init__(self)


ClientTypeCollectionConfiguration._set_binding_type(type.StructType(
    'com.vmware.nsx.model.client_type_collection_configuration', {
        'client_type': type.OptionalType(type.StringType()),
        'data_type_configurations': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'DataTypeCollectionConfiguration'))),
    },
    ClientTypeCollectionConfiguration,
    False,
    None))



class CloudNativeServiceInstance(VapiStruct):
    """
    Stores the information about cloud native service instance.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'external_id': 'external_id',
                            'service_type': 'service_type',
                            'source': 'source',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_last_sync_time': 'last_sync_time',
                            'description': 'description',
                            'display_name': 'display_name',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            }

    def __init__(self,
                 external_id=None,
                 service_type=None,
                 source=None,
                 links=None,
                 schema=None,
                 self_=None,
                 last_sync_time=None,
                 description=None,
                 display_name=None,
                 resource_type=None,
                 tags=None,
                ):
        """
        :type  external_id: :class:`str` or ``None``
        :param external_id: Id of service instance fetched from public cloud.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  service_type: :class:`str` or ``None``
        :param service_type: Type of cloud native service.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  source: :class:`ResourceReference` or ``None``
        :param source: Reference of the public cloud gateway that reported the service
            instance.
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  last_sync_time: :class:`long` or ``None``
        :param last_sync_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  resource_type: :class:`str`
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        """
        self.external_id = external_id
        self.service_type = service_type
        self.source = source
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.last_sync_time = last_sync_time
        self.description = description
        self.display_name = display_name
        self._resource_type = resource_type
        self.tags = tags
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

CloudNativeServiceInstance._set_binding_type(type.StructType(
    'com.vmware.nsx.model.cloud_native_service_instance', {
        'external_id': type.OptionalType(type.StringType()),
        'service_type': type.OptionalType(type.StringType()),
        'source': type.OptionalType(type.ReferenceType(__name__, 'ResourceReference')),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_last_sync_time': type.OptionalType(type.IntegerType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
    },
    CloudNativeServiceInstance,
    False,
    None))



class CloudNativeServiceInstanceListResult(VapiStruct):
    """
    Stores a list of cloud native service instances and information about them.
    NSX supported service instances are currently limited to Relational
    Database Service (RDS),Elastic Load Balancing (ELB).

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`CloudNativeServiceInstance` or ``None``
        :param results: List of cloud native service instances
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


CloudNativeServiceInstanceListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.cloud_native_service_instance_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'CloudNativeServiceInstance'))),
    },
    CloudNativeServiceInstanceListResult,
    False,
    None))



class ClusterBackupInfo(VapiStruct):
    """
    Cluster backup details

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    RESTORE_TYPE_REGULAR_RESTORE = "REGULAR_RESTORE"
    """


    """
    RESTORE_TYPE_POLICY_ONLY_RESTORE = "POLICY_ONLY_RESTORE"
    """


    """



    _canonical_to_pep_names = {
                            'ip_address': 'ip_address',
                            'node_id': 'node_id',
                            'restore_type': 'restore_type',
                            'timestamp': 'timestamp',
                            }

    def __init__(self,
                 ip_address=None,
                 node_id=None,
                 restore_type=None,
                 timestamp=None,
                ):
        """
        :type  ip_address: :class:`str` or ``None``
        :param ip_address: IP address or FQDN of the node from which the backup was taken
            format: hostname-or-ip
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  node_id: :class:`str` or ``None``
        :param node_id: ID of the node from which the backup was taken
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  restore_type: :class:`list` of :class:`str` or ``None``
        :param restore_type: Possible values are: 
            
            * :attr:`ClusterBackupInfo.RESTORE_TYPE_REGULAR_RESTORE`
            * :attr:`ClusterBackupInfo.RESTORE_TYPE_POLICY_ONLY_RESTORE`
            
             Type of restore allowed
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  timestamp: :class:`long` or ``None``
        :param timestamp: timestamp of the cluster backup file format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.ip_address = ip_address
        self.node_id = node_id
        self.restore_type = restore_type
        self.timestamp = timestamp
        VapiStruct.__init__(self)


ClusterBackupInfo._set_binding_type(type.StructType(
    'com.vmware.nsx.model.cluster_backup_info', {
        'ip_address': type.OptionalType(type.StringType()),
        'node_id': type.OptionalType(type.StringType()),
        'restore_type': type.OptionalType(type.ListType(type.StringType())),
        'timestamp': type.OptionalType(type.IntegerType()),
    },
    ClusterBackupInfo,
    False,
    None))



class ClusterBackupInfoListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`ClusterBackupInfo` or ``None``
        :param results: List of timestamps of backed-up cluster files
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


ClusterBackupInfoListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.cluster_backup_info_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ClusterBackupInfo'))),
    },
    ClusterBackupInfoListResult,
    False,
    None))



class ClusterCertificateId(VapiStruct):
    """
    Cluster Certificate ID

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'certificate_id': 'certificate_id',
                            }

    def __init__(self,
                 certificate_id=None,
                ):
        """
        :type  certificate_id: :class:`str` or ``None``
        :param certificate_id: Certificate ID
        """
        self.certificate_id = certificate_id
        VapiStruct.__init__(self)


ClusterCertificateId._set_binding_type(type.StructType(
    'com.vmware.nsx.model.cluster_certificate_id', {
        'certificate_id': type.OptionalType(type.StringType()),
    },
    ClusterCertificateId,
    False,
    None))



class ClusterConfig(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            'cluster_id': 'cluster_id',
                            'control_cluster_changes_allowed': 'control_cluster_changes_allowed',
                            'mgmt_cluster_changes_allowed': 'mgmt_cluster_changes_allowed',
                            'nodes': 'nodes',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 cluster_id=None,
                 control_cluster_changes_allowed=None,
                 mgmt_cluster_changes_allowed=None,
                 nodes=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  cluster_id: :class:`str` or ``None``
        :param cluster_id: Unique identifier of this cluster
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  control_cluster_changes_allowed: :class:`bool` or ``None``
        :param control_cluster_changes_allowed: True if control cluster nodes may be added or removed
        :type  mgmt_cluster_changes_allowed: :class:`bool` or ``None``
        :param mgmt_cluster_changes_allowed: True if management cluster nodes may be added or removed
        :type  nodes: :class:`list` of :class:`ClusterNodeInfo` or ``None``
        :param nodes: Configuration of each node in cluster
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.cluster_id = cluster_id
        self.control_cluster_changes_allowed = control_cluster_changes_allowed
        self.mgmt_cluster_changes_allowed = mgmt_cluster_changes_allowed
        self.nodes = nodes
        VapiStruct.__init__(self)


ClusterConfig._set_binding_type(type.StructType(
    'com.vmware.nsx.model.cluster_config', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        'cluster_id': type.OptionalType(type.StringType()),
        'control_cluster_changes_allowed': type.OptionalType(type.BooleanType()),
        'mgmt_cluster_changes_allowed': type.OptionalType(type.BooleanType()),
        'nodes': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ClusterNodeInfo'))),
    },
    ClusterConfig,
    False,
    None))



class ClusterConfiguration(VapiStruct):
    """
    The configuration of the NSX cluster. The cluster configuration consists of
    a list of cluster node attributes.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'cluster_id': 'cluster_id',
                            'config_version': 'config_version',
                            'nodes': 'nodes',
                            }

    def __init__(self,
                 cluster_id=None,
                 config_version=None,
                 nodes=None,
                ):
        """
        :type  cluster_id: :class:`str` or ``None``
        :param cluster_id: UUID of the cluster
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  config_version: :class:`long` or ``None``
        :param config_version: Cluster configuration version format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  nodes: :class:`list` of :class:`ClusterNode` or ``None``
        :param nodes: Nodes in the cluster configuration
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.cluster_id = cluster_id
        self.config_version = config_version
        self.nodes = nodes
        VapiStruct.__init__(self)


ClusterConfiguration._set_binding_type(type.StructType(
    'com.vmware.nsx.model.cluster_configuration', {
        'cluster_id': type.OptionalType(type.StringType()),
        'config_version': type.OptionalType(type.IntegerType()),
        'nodes': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ClusterNode'))),
    },
    ClusterConfiguration,
    False,
    None))



class ClusterGroupMemberStatus(VapiStruct):
    """
    This type contains the attributes and status of a group member.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    MEMBER_STATUS_UP = "UP"
    """


    """
    MEMBER_STATUS_DOWN = "DOWN"
    """


    """
    MEMBER_STATUS_UNKNOWN = "UNKNOWN"
    """


    """



    _canonical_to_pep_names = {
                            'member_fqdn': 'member_fqdn',
                            'member_ip': 'member_ip',
                            'member_status': 'member_status',
                            'member_uuid': 'member_uuid',
                            }

    def __init__(self,
                 member_fqdn=None,
                 member_ip=None,
                 member_status=None,
                 member_uuid=None,
                ):
        """
        :type  member_fqdn: :class:`str` or ``None``
        :param member_fqdn: FQDN of the group member format: hostname
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  member_ip: :class:`str` or ``None``
        :param member_ip: IP of the group member format: ip
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  member_status: :class:`str` or ``None``
        :param member_status: Possible values are: 
            
            * :attr:`ClusterGroupMemberStatus.MEMBER_STATUS_UP`
            * :attr:`ClusterGroupMemberStatus.MEMBER_STATUS_DOWN`
            * :attr:`ClusterGroupMemberStatus.MEMBER_STATUS_UNKNOWN`
            
             Status of the group member
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  member_uuid: :class:`str` or ``None``
        :param member_uuid: UUID of the group member
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.member_fqdn = member_fqdn
        self.member_ip = member_ip
        self.member_status = member_status
        self.member_uuid = member_uuid
        VapiStruct.__init__(self)


ClusterGroupMemberStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.cluster_group_member_status', {
        'member_fqdn': type.OptionalType(type.StringType()),
        'member_ip': type.OptionalType(type.StringType()),
        'member_status': type.OptionalType(type.StringType()),
        'member_uuid': type.OptionalType(type.StringType()),
    },
    ClusterGroupMemberStatus,
    False,
    None))



class ClusterGroupServiceLeader(VapiStruct):
    """
    Each cluster node entity provides multiple services. When working in a
    group, each service can elect a cluster node entity to be the leader of the
    service. Leader election helps in coordination of the service. The leader
    holds a renewable lease on the leadership for a fixed period of time. The
    lease version is incremented every time the leadership lease is renewed.
    This type contains the attributes of a leader.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'leader_uuid': 'leader_uuid',
                            'lease_version': 'lease_version',
                            'service_name': 'service_name',
                            }

    def __init__(self,
                 leader_uuid=None,
                 lease_version=None,
                 service_name=None,
                ):
        """
        :type  leader_uuid: :class:`str` or ``None``
        :param leader_uuid: Member UUID of the leader
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  lease_version: :class:`long` or ``None``
        :param lease_version: Number of times the lease has been renewed format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  service_name: :class:`str` or ``None``
        :param service_name: Name of the service
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.leader_uuid = leader_uuid
        self.lease_version = lease_version
        self.service_name = service_name
        VapiStruct.__init__(self)


ClusterGroupServiceLeader._set_binding_type(type.StructType(
    'com.vmware.nsx.model.cluster_group_service_leader', {
        'leader_uuid': type.OptionalType(type.StringType()),
        'lease_version': type.OptionalType(type.IntegerType()),
        'service_name': type.OptionalType(type.StringType()),
    },
    ClusterGroupServiceLeader,
    False,
    None))



class ClusterGroupStatus(VapiStruct):
    """
    This type contains the attributes and status of a group.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    GROUP_STATUS_STABLE = "STABLE"
    """


    """
    GROUP_STATUS_DEGRADED = "DEGRADED"
    """


    """
    GROUP_STATUS_UNSTABLE = "UNSTABLE"
    """


    """
    GROUP_STATUS_UNAVAILABLE = "UNAVAILABLE"
    """


    """
    GROUP_TYPE_MANAGER = "MANAGER"
    """


    """
    GROUP_TYPE_CONTROLLER = "CONTROLLER"
    """


    """
    GROUP_TYPE_POLICY = "POLICY"
    """


    """
    GROUP_TYPE_HTTPS = "HTTPS"
    """


    """
    GROUP_TYPE_DATASTORE = "DATASTORE"
    """


    """
    GROUP_TYPE_CLUSTER_BOOT_MANAGER = "CLUSTER_BOOT_MANAGER"
    """


    """
    GROUP_TYPE_GLOBAL_MANAGER = "GLOBAL_MANAGER"
    """


    """
    GROUP_TYPE_ASYNC_REPLICATOR = "ASYNC_REPLICATOR"
    """


    """
    GROUP_TYPE_MONITORING = "MONITORING"
    """


    """
    GROUP_TYPE_IDPS_REPORTING = "IDPS_REPORTING"
    """


    """
    GROUP_TYPE_CORFU_NONCONFIG = "CORFU_NONCONFIG"
    """


    """



    _canonical_to_pep_names = {
                            'group_id': 'group_id',
                            'group_status': 'group_status',
                            'group_type': 'group_type',
                            'leaders': 'leaders',
                            'members': 'members',
                            }

    def __init__(self,
                 group_id=None,
                 group_status=None,
                 group_type=None,
                 leaders=None,
                 members=None,
                ):
        """
        :type  group_id: :class:`str` or ``None``
        :param group_id: UUID of the group
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  group_status: :class:`str` or ``None``
        :param group_status: Possible values are: 
            
            * :attr:`ClusterGroupStatus.GROUP_STATUS_STABLE`
            * :attr:`ClusterGroupStatus.GROUP_STATUS_DEGRADED`
            * :attr:`ClusterGroupStatus.GROUP_STATUS_UNSTABLE`
            * :attr:`ClusterGroupStatus.GROUP_STATUS_UNAVAILABLE`
            
             Group status
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  group_type: :class:`str` or ``None``
        :param group_type: Possible values are: 
            
            * :attr:`ClusterGroupStatus.GROUP_TYPE_MANAGER`
            * :attr:`ClusterGroupStatus.GROUP_TYPE_CONTROLLER`
            * :attr:`ClusterGroupStatus.GROUP_TYPE_POLICY`
            * :attr:`ClusterGroupStatus.GROUP_TYPE_HTTPS`
            * :attr:`ClusterGroupStatus.GROUP_TYPE_DATASTORE`
            * :attr:`ClusterGroupStatus.GROUP_TYPE_CLUSTER_BOOT_MANAGER`
            * :attr:`ClusterGroupStatus.GROUP_TYPE_GLOBAL_MANAGER`
            * :attr:`ClusterGroupStatus.GROUP_TYPE_ASYNC_REPLICATOR`
            * :attr:`ClusterGroupStatus.GROUP_TYPE_MONITORING`
            * :attr:`ClusterGroupStatus.GROUP_TYPE_IDPS_REPORTING`
            * :attr:`ClusterGroupStatus.GROUP_TYPE_CORFU_NONCONFIG`
            
             Type of the group
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  leaders: :class:`list` of :class:`ClusterGroupServiceLeader` or ``None``
        :param leaders: Array of group leaders and their attributes
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  members: :class:`list` of :class:`ClusterGroupMemberStatus` or ``None``
        :param members: Array of group members and their statuses
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.group_id = group_id
        self.group_status = group_status
        self.group_type = group_type
        self.leaders = leaders
        self.members = members
        VapiStruct.__init__(self)


ClusterGroupStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.cluster_group_status', {
        'group_id': type.OptionalType(type.StringType()),
        'group_status': type.OptionalType(type.StringType()),
        'group_type': type.OptionalType(type.StringType()),
        'leaders': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ClusterGroupServiceLeader'))),
        'members': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ClusterGroupMemberStatus'))),
    },
    ClusterGroupStatus,
    False,
    None))



class ClusterInitializationNodeInfo(VapiStruct):
    """
    The type provides the information of a non-running cluster node required
    for the initialization of a management cluster. The administrator needs to
    start this node for management cluster to initialize properly (or
    decommission it explicitly).

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'disk_store_id': 'disk_store_id',
                            'host_address': 'host_address',
                            }

    def __init__(self,
                 disk_store_id=None,
                 host_address=None,
                ):
        """
        :type  disk_store_id: :class:`str` or ``None``
        :param disk_store_id: The (internal) disk-store ID of the member
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  host_address: :class:`str` or ``None``
        :param host_address: The IP address (or domain name) of the cluster node
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.disk_store_id = disk_store_id
        self.host_address = host_address
        VapiStruct.__init__(self)


ClusterInitializationNodeInfo._set_binding_type(type.StructType(
    'com.vmware.nsx.model.cluster_initialization_node_info', {
        'disk_store_id': type.OptionalType(type.StringType()),
        'host_address': type.OptionalType(type.StringType()),
    },
    ClusterInitializationNodeInfo,
    False,
    None))



class ClusterNode(VapiStruct):
    """
    This type contains attributes of a cluster node that are relevant to the
    Cluster Boot Manager.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATUS_JOINING = "JOINING"
    """


    """
    STATUS_JOINED = "JOINED"
    """


    """
    STATUS_REMOVING = "REMOVING"
    """


    """
    STATUS_REMOVED = "REMOVED"
    """


    """



    _canonical_to_pep_names = {
                            'entities': 'entities',
                            'node_uuid': 'node_uuid',
                            'status': 'status',
                            }

    def __init__(self,
                 entities=None,
                 node_uuid=None,
                 status=None,
                ):
        """
        :type  entities: :class:`list` of :class:`ClusterNodeEntity` or ``None``
        :param entities: Entities on the node
        :type  node_uuid: :class:`str` or ``None``
        :param node_uuid: UUID of the node
        :type  status: :class:`str` or ``None``
        :param status: Possible values are: 
            
            * :attr:`ClusterNode.STATUS_JOINING`
            * :attr:`ClusterNode.STATUS_JOINED`
            * :attr:`ClusterNode.STATUS_REMOVING`
            * :attr:`ClusterNode.STATUS_REMOVED`
            
             Current clustering status of the node
        """
        self.entities = entities
        self.node_uuid = node_uuid
        self.status = status
        VapiStruct.__init__(self)


ClusterNode._set_binding_type(type.StructType(
    'com.vmware.nsx.model.cluster_node', {
        'entities': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ClusterNodeEntity'))),
        'node_uuid': type.OptionalType(type.StringType()),
        'status': type.OptionalType(type.StringType()),
    },
    ClusterNode,
    False,
    None))



class ClusterNodeConfig(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'appliance_mgmt_listen_addr': 'appliance_mgmt_listen_addr',
                            'controller_role': 'controller_role',
                            'external_id': 'external_id',
                            'manager_role': 'manager_role',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 appliance_mgmt_listen_addr=None,
                 controller_role=None,
                 external_id=None,
                 manager_role=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  appliance_mgmt_listen_addr: :class:`str` or ``None``
        :param appliance_mgmt_listen_addr: The IP and port for the appliance management API service on this
            node
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  controller_role: :class:`ControllerClusterRoleConfig` or ``None``
        :param controller_role: 
        :type  external_id: :class:`str` or ``None``
        :param external_id: Internal identifier provided by the node
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  manager_role: :class:`ManagementClusterRoleConfig` or ``None``
        :param manager_role: 
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.appliance_mgmt_listen_addr = appliance_mgmt_listen_addr
        self.controller_role = controller_role
        self.external_id = external_id
        self.manager_role = manager_role
        VapiStruct.__init__(self)


ClusterNodeConfig._set_binding_type(type.StructType(
    'com.vmware.nsx.model.cluster_node_config', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'appliance_mgmt_listen_addr': type.OptionalType(type.StringType()),
        'controller_role': type.OptionalType(type.ReferenceType(__name__, 'ControllerClusterRoleConfig')),
        'external_id': type.OptionalType(type.StringType()),
        'manager_role': type.OptionalType(type.ReferenceType(__name__, 'ManagementClusterRoleConfig')),
    },
    ClusterNodeConfig,
    False,
    None))



class ClusterNodeConfigListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`ClusterNodeConfig` or ``None``
        :param results: Cluster node configuration results
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


ClusterNodeConfigListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.cluster_node_config_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ClusterNodeConfig'))),
    },
    ClusterNodeConfigListResult,
    False,
    None))



class ClusterNodeEntity(VapiStruct):
    """
    NSX Cluster is made up of multiple cluster nodes. Each node can perform
    multiple functions, commonly referred to as roles. Cluster node entities
    are processes running in a cluster node that assist in the performance of a
    role. Cluster Boot Manager is a daemon that securely bootstraps and
    configures the entities. This type contains attributes of a cluster node
    entity that are relevant to the Cluster Boot Manager.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    ENTITY_TYPE_MANAGER = "MANAGER"
    """


    """
    ENTITY_TYPE_CONTROLLER = "CONTROLLER"
    """


    """
    ENTITY_TYPE_POLICY = "POLICY"
    """


    """
    ENTITY_TYPE_HTTPS = "HTTPS"
    """


    """
    ENTITY_TYPE_CLUSTER_BOOT_MANAGER = "CLUSTER_BOOT_MANAGER"
    """


    """
    ENTITY_TYPE_DATASTORE = "DATASTORE"
    """


    """
    ENTITY_TYPE_GLOBAL_MANAGER = "GLOBAL_MANAGER"
    """


    """
    ENTITY_TYPE_ASYNC_REPLICATOR = "ASYNC_REPLICATOR"
    """


    """
    ENTITY_TYPE_MONITORING = "MONITORING"
    """


    """
    ENTITY_TYPE_IDPS_REPORTING = "IDPS_REPORTING"
    """


    """
    ENTITY_TYPE_CORFU_NONCONFIG = "CORFU_NONCONFIG"
    """


    """



    _canonical_to_pep_names = {
                            'certificate': 'certificate',
                            'entity_type': 'entity_type',
                            'entity_uuid': 'entity_uuid',
                            'fqdn': 'fqdn',
                            'ip_address': 'ip_address',
                            'port': 'port',
                            'subnet_prefix_length': 'subnet_prefix_length',
                            }

    def __init__(self,
                 certificate=None,
                 entity_type=None,
                 entity_uuid=None,
                 fqdn=None,
                 ip_address=None,
                 port=None,
                 subnet_prefix_length=None,
                ):
        """
        :type  certificate: :class:`str` or ``None``
        :param certificate: Public certificate of the entity in PEM format
        :type  entity_type: :class:`str` or ``None``
        :param entity_type: Possible values are: 
            
            * :attr:`ClusterNodeEntity.ENTITY_TYPE_MANAGER`
            * :attr:`ClusterNodeEntity.ENTITY_TYPE_CONTROLLER`
            * :attr:`ClusterNodeEntity.ENTITY_TYPE_POLICY`
            * :attr:`ClusterNodeEntity.ENTITY_TYPE_HTTPS`
            * :attr:`ClusterNodeEntity.ENTITY_TYPE_CLUSTER_BOOT_MANAGER`
            * :attr:`ClusterNodeEntity.ENTITY_TYPE_DATASTORE`
            * :attr:`ClusterNodeEntity.ENTITY_TYPE_GLOBAL_MANAGER`
            * :attr:`ClusterNodeEntity.ENTITY_TYPE_ASYNC_REPLICATOR`
            * :attr:`ClusterNodeEntity.ENTITY_TYPE_MONITORING`
            * :attr:`ClusterNodeEntity.ENTITY_TYPE_IDPS_REPORTING`
            * :attr:`ClusterNodeEntity.ENTITY_TYPE_CORFU_NONCONFIG`
            
             Type of the entity
        :type  entity_uuid: :class:`str` or ``None``
        :param entity_uuid: UUID of the entity
        :type  fqdn: :class:`str` or ``None``
        :param fqdn: Domain name the entity binds to format: hostname
        :type  ip_address: :class:`str` or ``None``
        :param ip_address: IP address the entity binds to
        :type  port: :class:`long` or ``None``
        :param port: Port the entity binds to format: int64
        :type  subnet_prefix_length: :class:`long` or ``None``
        :param subnet_prefix_length: Subnet mask prefix length of the entity binds to format: int64
        """
        self.certificate = certificate
        self.entity_type = entity_type
        self.entity_uuid = entity_uuid
        self.fqdn = fqdn
        self.ip_address = ip_address
        self.port = port
        self.subnet_prefix_length = subnet_prefix_length
        VapiStruct.__init__(self)


ClusterNodeEntity._set_binding_type(type.StructType(
    'com.vmware.nsx.model.cluster_node_entity', {
        'certificate': type.OptionalType(type.StringType()),
        'entity_type': type.OptionalType(type.StringType()),
        'entity_uuid': type.OptionalType(type.StringType()),
        'fqdn': type.OptionalType(type.StringType()),
        'ip_address': type.OptionalType(type.StringType()),
        'port': type.OptionalType(type.IntegerType()),
        'subnet_prefix_length': type.OptionalType(type.IntegerType()),
    },
    ClusterNodeEntity,
    False,
    None))



class ClusterNodeInfo(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATUS_JOINING = "JOINING"
    """


    """
    STATUS_JOINED = "JOINED"
    """


    """
    STATUS_REMOVING = "REMOVING"
    """


    """
    STATUS_REMOVED = "REMOVED"
    """


    """



    _canonical_to_pep_names = {
                            'certificates': 'certificates',
                            'display_name': 'display_name',
                            'entities': 'entities',
                            'fqdn': 'fqdn',
                            'msg_clients': 'msg_clients',
                            'node_uuid': 'node_uuid',
                            'status': 'status',
                            }

    def __init__(self,
                 certificates=None,
                 display_name=None,
                 entities=None,
                 fqdn=None,
                 msg_clients=None,
                 node_uuid=None,
                 status=None,
                ):
        """
        :type  certificates: :class:`list` of :class:`NodeCertificateInfo` or ``None``
        :param certificates: Certificate and thumbprint of all entities
        :type  display_name: :class:`str` or ``None``
        :param display_name: The display name of this node
        :type  entities: :class:`list` of :class:`NodeEntityInfo` or ``None``
        :param entities: Service endpoint of all entities
        :type  fqdn: :class:`str` or ``None``
        :param fqdn: The fqdn of this node
        :type  msg_clients: :class:`list` of :class:`NodeMessagingClientInfo` or ``None``
        :param msg_clients: Messaging client of all entities
        :type  node_uuid: :class:`str` or ``None``
        :param node_uuid: Unique identifier of this node
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  status: :class:`str` or ``None``
        :param status: Possible values are: 
            
            * :attr:`ClusterNodeInfo.STATUS_JOINING`
            * :attr:`ClusterNodeInfo.STATUS_JOINED`
            * :attr:`ClusterNodeInfo.STATUS_REMOVING`
            * :attr:`ClusterNodeInfo.STATUS_REMOVED`
            
             Node clustering status
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.certificates = certificates
        self.display_name = display_name
        self.entities = entities
        self.fqdn = fqdn
        self.msg_clients = msg_clients
        self.node_uuid = node_uuid
        self.status = status
        VapiStruct.__init__(self)


ClusterNodeInfo._set_binding_type(type.StructType(
    'com.vmware.nsx.model.cluster_node_info', {
        'certificates': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NodeCertificateInfo'))),
        'display_name': type.OptionalType(type.StringType()),
        'entities': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NodeEntityInfo'))),
        'fqdn': type.OptionalType(type.StringType()),
        'msg_clients': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NodeMessagingClientInfo'))),
        'node_uuid': type.OptionalType(type.StringType()),
        'status': type.OptionalType(type.StringType()),
    },
    ClusterNodeInfo,
    False,
    None))



class ClusterNodeStatus(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'control_cluster_status': 'control_cluster_status',
                            'mgmt_cluster_status': 'mgmt_cluster_status',
                            'system_status': 'system_status',
                            'version': 'version',
                            }

    def __init__(self,
                 control_cluster_status=None,
                 mgmt_cluster_status=None,
                 system_status=None,
                 version=None,
                ):
        """
        :type  control_cluster_status: :class:`ControlClusterNodeStatus` or ``None``
        :param control_cluster_status: Clustering status for control plane functions on this node
        :type  mgmt_cluster_status: :class:`ManagementClusterNodeStatus` or ``None``
        :param mgmt_cluster_status: Clustering status for management plane functions on this node
        :type  system_status: :class:`NodeStatusProperties` or ``None``
        :param system_status: Node status properties
        :type  version: :class:`str` or ``None``
        :param version: Software version running on node
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.control_cluster_status = control_cluster_status
        self.mgmt_cluster_status = mgmt_cluster_status
        self.system_status = system_status
        self.version = version
        VapiStruct.__init__(self)


ClusterNodeStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.cluster_node_status', {
        'control_cluster_status': type.OptionalType(type.ReferenceType(__name__, 'ControlClusterNodeStatus')),
        'mgmt_cluster_status': type.OptionalType(type.ReferenceType(__name__, 'ManagementClusterNodeStatus')),
        'system_status': type.OptionalType(type.ReferenceType(__name__, 'NodeStatusProperties')),
        'version': type.OptionalType(type.StringType()),
    },
    ClusterNodeStatus,
    False,
    None))



class ClusterNodeVMDeploymentConfig(VapiStruct):
    """
    Contains info used to configure the VM on deployment

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "ClusterNodeVMDeploymentConfig"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    PLACEMENT_TYPE_VSPHERECLUSTERNODEVMDEPLOYMENTCONFIG = "VsphereClusterNodeVMDeploymentConfig"
    """


    """



    _canonical_to_pep_names = {
                            'placement_type': 'placement_type',
                            }

    def __init__(self,
                 placement_type='ClusterNodeVMDeploymentConfig',
                ):
        """
        :type  placement_type: :class:`str`
        :param placement_type: Possible values are: 
            
            *
              :attr:`ClusterNodeVMDeploymentConfig.PLACEMENT_TYPE_VSPHERECLUSTERNODEVMDEPLOYMENTCONFIG`
            
            Specifies the config for the platform through which to deploy the
            VM
        """
        self._placement_type = placement_type
        VapiStruct.__init__(self)

    @property
    def placement_type(self):
        """
        Return the discriminator value
        """
        return self._placement_type

ClusterNodeVMDeploymentConfig._set_binding_type(type.StructType(
    'com.vmware.nsx.model.cluster_node_VM_deployment_config', {
        'placement_type': type.StringType(),
    },
    ClusterNodeVMDeploymentConfig,
    False,
    None))



class ClusterNodeVMDeploymentProgressState(VapiStruct):
    """
    Deployment progress state of node VM. This Object contains name of current
    deployment step and overall progress percentage.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'current_step_title': 'current_step_title',
                            'progress': 'progress',
                            }

    def __init__(self,
                 current_step_title=None,
                 progress=None,
                ):
        """
        :type  current_step_title: :class:`str` or ``None``
        :param current_step_title: Name of the current running step of deployment
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  progress: :class:`long` or ``None``
        :param progress: Overall progress percentage of deployment completed format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.current_step_title = current_step_title
        self.progress = progress
        VapiStruct.__init__(self)


ClusterNodeVMDeploymentProgressState._set_binding_type(type.StructType(
    'com.vmware.nsx.model.cluster_node_VM_deployment_progress_state', {
        'current_step_title': type.OptionalType(type.StringType()),
        'progress': type.OptionalType(type.IntegerType()),
    },
    ClusterNodeVMDeploymentProgressState,
    False,
    None))



class ClusterNodeVMDeploymentRequest(VapiStruct):
    """
    Contains the deployment information for a cluster node VM soon to be
    deployed or already deployed by the Manager

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    FORM_FACTOR_SMALL = "SMALL"
    """


    """
    FORM_FACTOR_MEDIUM = "MEDIUM"
    """


    """
    FORM_FACTOR_LARGE = "LARGE"
    """


    """
    ROLES_CONTROLLER = "CONTROLLER"
    """


    """
    ROLES_MANAGER = "MANAGER"
    """


    """



    _canonical_to_pep_names = {
                            'deployment_config': 'deployment_config',
                            'form_factor': 'form_factor',
                            'roles': 'roles',
                            'user_settings': 'user_settings',
                            'vm_id': 'vm_id',
                            }

    def __init__(self,
                 deployment_config=None,
                 form_factor=None,
                 roles=None,
                 user_settings=None,
                 vm_id=None,
                ):
        """
        :type  deployment_config: :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param deployment_config: Info needed to configure a cluster node VM at deployment for a
            specific platform. May require different parameters depending on
            the method used to deploy the VM.
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`ClusterNodeVMDeploymentConfig`. When methods return a value
            of this class as a return value, the attribute will contain all the
            attributes defined in :class:`ClusterNodeVMDeploymentConfig`.
        :type  form_factor: :class:`str` or ``None``
        :param form_factor: Possible values are: 
            
            * :attr:`ClusterNodeVMDeploymentRequest.FORM_FACTOR_SMALL`
            * :attr:`ClusterNodeVMDeploymentRequest.FORM_FACTOR_MEDIUM`
            * :attr:`ClusterNodeVMDeploymentRequest.FORM_FACTOR_LARGE`
            
             Specifies the desired \"size\" of the VM
        :type  roles: :class:`list` of :class:`str` or ``None``
        :param roles: Possible values are: 
            
            * :attr:`ClusterNodeVMDeploymentRequest.ROLES_CONTROLLER`
            * :attr:`ClusterNodeVMDeploymentRequest.ROLES_MANAGER`
            
            List of cluster node role (or roles) which the VM should take on.
            They specify what type (or types) of cluster node which the new VM
            should act as. Currently both CONTROLLER and MANAGER must be
            provided, since this permutation is the only one supported now.
        :type  user_settings: :class:`NodeUserSettings` or ``None``
        :param user_settings: Username and password settings for the cluster node VM. Passwords
            must be at least 12 characters in length and contain at least one
            lowercase, one uppercase, one numerical, and one special character.
            Note: These settings will be honored only during VM deployment.
            Post-deployment, CLI must be used for changing the user settings
            and changes to these parameters will not have any effect.
        :type  vm_id: :class:`str` or ``None``
        :param vm_id: ID of the VM maintained internally and used to recognize it. Note:
            This is automatically generated and cannot be modified.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.deployment_config = deployment_config
        self.form_factor = form_factor
        self.roles = roles
        self.user_settings = user_settings
        self.vm_id = vm_id
        VapiStruct.__init__(self)


ClusterNodeVMDeploymentRequest._set_binding_type(type.StructType(
    'com.vmware.nsx.model.cluster_node_VM_deployment_request', {
        'deployment_config': type.OptionalType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'ClusterNodeVMDeploymentConfig')])),
        'form_factor': type.OptionalType(type.StringType()),
        'roles': type.OptionalType(type.ListType(type.StringType())),
        'user_settings': type.OptionalType(type.ReferenceType(__name__, 'NodeUserSettings')),
        'vm_id': type.OptionalType(type.StringType()),
    },
    ClusterNodeVMDeploymentRequest,
    False,
    None))



class ClusterNodeVMDeploymentRequestList(VapiStruct):
    """
    List of ClusterNodeVMDeploymentRequests

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`ClusterNodeVMDeploymentRequest` or ``None``
        :param results: Array of existing ClusterNodeVMDeploymentRequests
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


ClusterNodeVMDeploymentRequestList._set_binding_type(type.StructType(
    'com.vmware.nsx.model.cluster_node_VM_deployment_request_list', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ClusterNodeVMDeploymentRequest'))),
    },
    ClusterNodeVMDeploymentRequestList,
    False,
    None))



class ClusterNodeVMDeploymentStatusReport(VapiStruct):
    """
    Contains up-to-date information relating to an auto-deployed VM, including
    its status and (potentially) an error message.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATUS_UNKNOWN_STATE = "UNKNOWN_STATE"
    """


    """
    STATUS_VM_DEPLOYMENT_QUEUED = "VM_DEPLOYMENT_QUEUED"
    """


    """
    STATUS_VM_DEPLOYMENT_IN_PROGRESS = "VM_DEPLOYMENT_IN_PROGRESS"
    """


    """
    STATUS_VM_DEPLOYMENT_FAILED = "VM_DEPLOYMENT_FAILED"
    """


    """
    STATUS_VM_POWER_ON_IN_PROGRESS = "VM_POWER_ON_IN_PROGRESS"
    """


    """
    STATUS_VM_POWER_ON_FAILED = "VM_POWER_ON_FAILED"
    """


    """
    STATUS_WAITING_TO_REGISTER_VM = "WAITING_TO_REGISTER_VM"
    """


    """
    STATUS_VM_REGISTRATION_FAILED = "VM_REGISTRATION_FAILED"
    """


    """
    STATUS_VM_WAITING_TO_CLUSTER = "VM_WAITING_TO_CLUSTER"
    """


    """
    STATUS_VM_WAITING_TO_COME_ONLINE = "VM_WAITING_TO_COME_ONLINE"
    """


    """
    STATUS_VM_ONLINE_FAILED = "VM_ONLINE_FAILED"
    """


    """
    STATUS_VM_CLUSTERING_IN_PROGRESS = "VM_CLUSTERING_IN_PROGRESS"
    """


    """
    STATUS_VM_CLUSTERING_FAILED = "VM_CLUSTERING_FAILED"
    """


    """
    STATUS_VM_CLUSTERING_SUCCESSFUL = "VM_CLUSTERING_SUCCESSFUL"
    """


    """
    STATUS_WAITING_TO_UNDEPLOY_VM = "WAITING_TO_UNDEPLOY_VM"
    """


    """
    STATUS_VM_DECLUSTER_IN_PROGRESS = "VM_DECLUSTER_IN_PROGRESS"
    """


    """
    STATUS_VM_DECLUSTER_FAILED = "VM_DECLUSTER_FAILED"
    """


    """
    STATUS_VM_DECLUSTER_SUCCESSFUL = "VM_DECLUSTER_SUCCESSFUL"
    """


    """
    STATUS_VM_POWER_OFF_IN_PROGRESS = "VM_POWER_OFF_IN_PROGRESS"
    """


    """
    STATUS_VM_POWER_OFF_FAILED = "VM_POWER_OFF_FAILED"
    """


    """
    STATUS_VM_UNDEPLOY_IN_PROGRESS = "VM_UNDEPLOY_IN_PROGRESS"
    """


    """
    STATUS_VM_UNDEPLOY_FAILED = "VM_UNDEPLOY_FAILED"
    """


    """
    STATUS_VM_UNDEPLOY_SUCCESSFUL = "VM_UNDEPLOY_SUCCESSFUL"
    """


    """



    _canonical_to_pep_names = {
                            'deployment_progress_state': 'deployment_progress_state',
                            'failure_code': 'failure_code',
                            'failure_message': 'failure_message',
                            'status': 'status',
                            }

    def __init__(self,
                 deployment_progress_state=None,
                 failure_code=None,
                 failure_message=None,
                 status=None,
                ):
        """
        :type  deployment_progress_state: :class:`VMDeploymentProgressState` or ``None``
        :param deployment_progress_state: Detailed progress state of node VM deployment realization
        :type  failure_code: :class:`long` or ``None``
        :param failure_code: In case of auto-deployment-related failure, the code for the error
            will be stored here. format: int64
        :type  failure_message: :class:`str` or ``None``
        :param failure_message: In case of auto-deployment-related failure, an error message will
            be stored here.
        :type  status: :class:`str` or ``None``
        :param status: Possible values are: 
            
            * :attr:`ClusterNodeVMDeploymentStatusReport.STATUS_UNKNOWN_STATE`
            *
              :attr:`ClusterNodeVMDeploymentStatusReport.STATUS_VM_DEPLOYMENT_QUEUED`
            *
              :attr:`ClusterNodeVMDeploymentStatusReport.STATUS_VM_DEPLOYMENT_IN_PROGRESS`
            *
              :attr:`ClusterNodeVMDeploymentStatusReport.STATUS_VM_DEPLOYMENT_FAILED`
            *
              :attr:`ClusterNodeVMDeploymentStatusReport.STATUS_VM_POWER_ON_IN_PROGRESS`
            *
              :attr:`ClusterNodeVMDeploymentStatusReport.STATUS_VM_POWER_ON_FAILED`
            *
              :attr:`ClusterNodeVMDeploymentStatusReport.STATUS_WAITING_TO_REGISTER_VM`
            *
              :attr:`ClusterNodeVMDeploymentStatusReport.STATUS_VM_REGISTRATION_FAILED`
            *
              :attr:`ClusterNodeVMDeploymentStatusReport.STATUS_VM_WAITING_TO_CLUSTER`
            *
              :attr:`ClusterNodeVMDeploymentStatusReport.STATUS_VM_WAITING_TO_COME_ONLINE`
            *
              :attr:`ClusterNodeVMDeploymentStatusReport.STATUS_VM_ONLINE_FAILED`
            *
              :attr:`ClusterNodeVMDeploymentStatusReport.STATUS_VM_CLUSTERING_IN_PROGRESS`
            *
              :attr:`ClusterNodeVMDeploymentStatusReport.STATUS_VM_CLUSTERING_FAILED`
            *
              :attr:`ClusterNodeVMDeploymentStatusReport.STATUS_VM_CLUSTERING_SUCCESSFUL`
            *
              :attr:`ClusterNodeVMDeploymentStatusReport.STATUS_WAITING_TO_UNDEPLOY_VM`
            *
              :attr:`ClusterNodeVMDeploymentStatusReport.STATUS_VM_DECLUSTER_IN_PROGRESS`
            *
              :attr:`ClusterNodeVMDeploymentStatusReport.STATUS_VM_DECLUSTER_FAILED`
            *
              :attr:`ClusterNodeVMDeploymentStatusReport.STATUS_VM_DECLUSTER_SUCCESSFUL`
            *
              :attr:`ClusterNodeVMDeploymentStatusReport.STATUS_VM_POWER_OFF_IN_PROGRESS`
            *
              :attr:`ClusterNodeVMDeploymentStatusReport.STATUS_VM_POWER_OFF_FAILED`
            *
              :attr:`ClusterNodeVMDeploymentStatusReport.STATUS_VM_UNDEPLOY_IN_PROGRESS`
            *
              :attr:`ClusterNodeVMDeploymentStatusReport.STATUS_VM_UNDEPLOY_FAILED`
            *
              :attr:`ClusterNodeVMDeploymentStatusReport.STATUS_VM_UNDEPLOY_SUCCESSFUL`
            
            Status of the addition or deletion of an auto-deployed cluster node
            VM.
        """
        self.deployment_progress_state = deployment_progress_state
        self.failure_code = failure_code
        self.failure_message = failure_message
        self.status = status
        VapiStruct.__init__(self)


ClusterNodeVMDeploymentStatusReport._set_binding_type(type.StructType(
    'com.vmware.nsx.model.cluster_node_VM_deployment_status_report', {
        'deployment_progress_state': type.OptionalType(type.ReferenceType(__name__, 'VMDeploymentProgressState')),
        'failure_code': type.OptionalType(type.IntegerType()),
        'failure_message': type.OptionalType(type.StringType()),
        'status': type.OptionalType(type.StringType()),
    },
    ClusterNodeVMDeploymentStatusReport,
    False,
    None))



class ClusterProfile(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "ClusterProfile"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    RESOURCE_TYPE_EDGEHIGHAVAILABILITYPROFILE = "EdgeHighAvailabilityProfile"
    """


    """
    RESOURCE_TYPE_BRIDGEHIGHAVAILABILITYCLUSTERPROFILE = "BridgeHighAvailabilityClusterProfile"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='ClusterProfile',
                 tags=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`ClusterProfile.RESOURCE_TYPE_EDGEHIGHAVAILABILITYPROFILE`
            *
              :attr:`ClusterProfile.RESOURCE_TYPE_BRIDGEHIGHAVAILABILITYCLUSTERPROFILE`
            
             Supported cluster profiles.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

ClusterProfile._set_binding_type(type.StructType(
    'com.vmware.nsx.model.cluster_profile', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
    },
    ClusterProfile,
    False,
    None))



class ClusterProfileListResult(VapiStruct):
    """
    Cluster Profile queries result

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param results: Cluster Profile Results
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`ClusterProfile`. When methods return a value of this class
            as a return value, the attribute will contain all the attributes
            defined in :class:`ClusterProfile`.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


ClusterProfileListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.cluster_profile_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'ClusterProfile')]))),
    },
    ClusterProfileListResult,
    False,
    None))



class ClusterProfileTypeIdEntry(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    RESOURCE_TYPE_EDGEHIGHAVAILABILITYPROFILE = "EdgeHighAvailabilityProfile"
    """


    """
    RESOURCE_TYPE_BRIDGEHIGHAVAILABILITYCLUSTERPROFILE = "BridgeHighAvailabilityClusterProfile"
    """


    """



    _canonical_to_pep_names = {
                            'profile_id': 'profile_id',
                            'resource_type': 'resource_type',
                            }

    def __init__(self,
                 profile_id=None,
                 resource_type=None,
                ):
        """
        :type  profile_id: :class:`str` or ``None``
        :param profile_id: key value
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: Possible values are: 
            
            *
              :attr:`ClusterProfileTypeIdEntry.RESOURCE_TYPE_EDGEHIGHAVAILABILITYPROFILE`
            *
              :attr:`ClusterProfileTypeIdEntry.RESOURCE_TYPE_BRIDGEHIGHAVAILABILITYCLUSTERPROFILE`
            
             Supported cluster profiles.
        """
        self.profile_id = profile_id
        self.resource_type = resource_type
        VapiStruct.__init__(self)


ClusterProfileTypeIdEntry._set_binding_type(type.StructType(
    'com.vmware.nsx.model.cluster_profile_type_id_entry', {
        'profile_id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
    },
    ClusterProfileTypeIdEntry,
    False,
    None))



class ClusterRestoreStatus(VapiStruct):
    """
    Cluster restore status

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'backup_timestamp': 'backup_timestamp',
                            'endpoints': 'endpoints',
                            'id': 'id',
                            'instructions': 'instructions',
                            'restore_end_time': 'restore_end_time',
                            'restore_start_time': 'restore_start_time',
                            'status': 'status',
                            'step': 'step',
                            'total_steps': 'total_steps',
                            }

    def __init__(self,
                 backup_timestamp=None,
                 endpoints=None,
                 id=None,
                 instructions=None,
                 restore_end_time=None,
                 restore_start_time=None,
                 status=None,
                 step=None,
                 total_steps=None,
                ):
        """
        :type  backup_timestamp: :class:`long` or ``None``
        :param backup_timestamp: Timestamp when backup was initiated in epoch millisecond format:
            int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  endpoints: :class:`list` of :class:`ResourceLink` or ``None``
        :param endpoints: The list of allowed endpoints, based on the current state of the
            restore process
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  id: :class:`str` or ``None``
        :param id: Unique id for backup request
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  instructions: :class:`list` of :class:`InstructionInfo` or ``None``
        :param instructions: Instructions for users to reconcile Restore operations
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  restore_end_time: :class:`long` or ``None``
        :param restore_end_time: Timestamp when restore was completed in epoch millisecond format:
            int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  restore_start_time: :class:`long` or ``None``
        :param restore_start_time: Timestamp when restore was started in epoch millisecond format:
            int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  status: :class:`GlobalRestoreStatus` or ``None``
        :param status: 
        :type  step: :class:`RestoreStep` or ``None``
        :param step: 
        :type  total_steps: :class:`long` or ``None``
        :param total_steps: Total number of steps in the entire restore process format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.backup_timestamp = backup_timestamp
        self.endpoints = endpoints
        self.id = id
        self.instructions = instructions
        self.restore_end_time = restore_end_time
        self.restore_start_time = restore_start_time
        self.status = status
        self.step = step
        self.total_steps = total_steps
        VapiStruct.__init__(self)


ClusterRestoreStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.cluster_restore_status', {
        'backup_timestamp': type.OptionalType(type.IntegerType()),
        'endpoints': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        'id': type.OptionalType(type.StringType()),
        'instructions': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'InstructionInfo'))),
        'restore_end_time': type.OptionalType(type.IntegerType()),
        'restore_start_time': type.OptionalType(type.IntegerType()),
        'status': type.OptionalType(type.ReferenceType(__name__, 'GlobalRestoreStatus')),
        'step': type.OptionalType(type.ReferenceType(__name__, 'RestoreStep')),
        'total_steps': type.OptionalType(type.IntegerType()),
    },
    ClusterRestoreStatus,
    False,
    None))



class ClusterRoleConfig(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    TYPE_MANAGEMENTCLUSTERROLECONFIG = "ManagementClusterRoleConfig"
    """


    """
    TYPE_CONTROLLERCLUSTERROLECONFIG = "ControllerClusterRoleConfig"
    """


    """



    _canonical_to_pep_names = {
                            'type': 'type',
                            }

    def __init__(self,
                 type=None,
                ):
        """
        :type  type: :class:`str` or ``None``
        :param type: Possible values are: 
            
            * :attr:`ClusterRoleConfig.TYPE_MANAGEMENTCLUSTERROLECONFIG`
            * :attr:`ClusterRoleConfig.TYPE_CONTROLLERCLUSTERROLECONFIG`
            
             Type of this role configuration
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.type = type
        VapiStruct.__init__(self)


ClusterRoleConfig._set_binding_type(type.StructType(
    'com.vmware.nsx.model.cluster_role_config', {
        'type': type.OptionalType(type.StringType()),
    },
    ClusterRoleConfig,
    False,
    None))



class ClusterStatus(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'cluster_id': 'cluster_id',
                            'control_cluster_status': 'control_cluster_status',
                            'detailed_cluster_status': 'detailed_cluster_status',
                            'mgmt_cluster_status': 'mgmt_cluster_status',
                            }

    def __init__(self,
                 cluster_id=None,
                 control_cluster_status=None,
                 detailed_cluster_status=None,
                 mgmt_cluster_status=None,
                ):
        """
        :type  cluster_id: :class:`str` or ``None``
        :param cluster_id: Unique identifier of this cluster
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  control_cluster_status: :class:`ControllerClusterStatus` or ``None``
        :param control_cluster_status: The current status of the control cluster
        :type  detailed_cluster_status: :class:`AllClusterGroupStatus` or ``None``
        :param detailed_cluster_status: Status of all the cluster groups
        :type  mgmt_cluster_status: :class:`ManagementClusterStatus` or ``None``
        :param mgmt_cluster_status: The current status of the management cluster
        """
        self.cluster_id = cluster_id
        self.control_cluster_status = control_cluster_status
        self.detailed_cluster_status = detailed_cluster_status
        self.mgmt_cluster_status = mgmt_cluster_status
        VapiStruct.__init__(self)


ClusterStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.cluster_status', {
        'cluster_id': type.OptionalType(type.StringType()),
        'control_cluster_status': type.OptionalType(type.ReferenceType(__name__, 'ControllerClusterStatus')),
        'detailed_cluster_status': type.OptionalType(type.ReferenceType(__name__, 'AllClusterGroupStatus')),
        'mgmt_cluster_status': type.OptionalType(type.ReferenceType(__name__, 'ManagementClusterStatus')),
    },
    ClusterStatus,
    False,
    None))



class ClusterVirtualIpProperties(VapiStruct):
    """
    Cluster virtual IP properties

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'ip_address': 'ip_address',
                            }

    def __init__(self,
                 ip_address=None,
                ):
        """
        :type  ip_address: :class:`str` or ``None``
        :param ip_address: Virtual IP address, 0.0.0.0 if not configured
        """
        self.ip_address = ip_address
        VapiStruct.__init__(self)


ClusterVirtualIpProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.cluster_virtual_ip_properties', {
        'ip_address': type.OptionalType(type.StringType()),
    },
    ClusterVirtualIpProperties,
    False,
    None))



class ClusteringConfig(VapiStruct):
    """
    Configuration for automatically joining a cluster node to the cluster after
    it is deployed. ClusteringConfig is required if any of the deployment nodes
    has CONTROLLER role.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "ClusteringConfig"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    CLUSTERING_TYPE_CONTROLCLUSTERINGCONFIG = "ControlClusteringConfig"
    """


    """



    _canonical_to_pep_names = {
                            'clustering_type': 'clustering_type',
                            }

    def __init__(self,
                 clustering_type='ClusteringConfig',
                ):
        """
        :type  clustering_type: :class:`str`
        :param clustering_type: Possible values are: 
            
            * :attr:`ClusteringConfig.CLUSTERING_TYPE_CONTROLCLUSTERINGCONFIG`
            
             Specifies the type of clustering config to be used.
        """
        self._clustering_type = clustering_type
        VapiStruct.__init__(self)

    @property
    def clustering_type(self):
        """
        Return the discriminator value
        """
        return self._clustering_type

ClusteringConfig._set_binding_type(type.StructType(
    'com.vmware.nsx.model.clustering_config', {
        'clustering_type': type.StringType(),
    },
    ClusteringConfig,
    False,
    None))



class ClusteringInfo(VapiStruct):
    """
    Clustering parameters for the controller cluster

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'join_to_existing_cluster': 'join_to_existing_cluster',
                            'shared_secret': 'shared_secret',
                            }

    def __init__(self,
                 join_to_existing_cluster=None,
                 shared_secret=None,
                ):
        """
        :type  join_to_existing_cluster: :class:`bool` or ``None``
        :param join_to_existing_cluster: Property to indicate if the node must join an existing cluster.
        :type  shared_secret: :class:`str` or ``None``
        :param shared_secret: Shared secret of the cluster.
        """
        self.join_to_existing_cluster = join_to_existing_cluster
        self.shared_secret = shared_secret
        VapiStruct.__init__(self)


ClusteringInfo._set_binding_type(type.StructType(
    'com.vmware.nsx.model.clustering_info', {
        'join_to_existing_cluster': type.OptionalType(type.BooleanType()),
        'shared_secret': type.OptionalType(type.StringType()),
    },
    ClusteringInfo,
    False,
    None))



class ClustersAggregateInfo(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'cluster_status': 'cluster_status',
                            'controller_cluster': 'controller_cluster',
                            'management_cluster': 'management_cluster',
                            }

    def __init__(self,
                 cluster_status=None,
                 controller_cluster=None,
                 management_cluster=None,
                ):
        """
        :type  cluster_status: :class:`AllClusterGroupStatus` or ``None``
        :param cluster_status: Status of all the cluster groups
        :type  controller_cluster: :class:`list` of :class:`ControllerNodeAggregateInfo` or ``None``
        :param controller_cluster: Array of Controller Nodes
        :type  management_cluster: :class:`list` of :class:`ManagementNodeAggregateInfo` or ``None``
        :param management_cluster: Array of Management Nodes
        """
        self.cluster_status = cluster_status
        self.controller_cluster = controller_cluster
        self.management_cluster = management_cluster
        VapiStruct.__init__(self)


ClustersAggregateInfo._set_binding_type(type.StructType(
    'com.vmware.nsx.model.clusters_aggregate_info', {
        'cluster_status': type.OptionalType(type.ReferenceType(__name__, 'AllClusterGroupStatus')),
        'controller_cluster': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ControllerNodeAggregateInfo'))),
        'management_cluster': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ManagementNodeAggregateInfo'))),
    },
    ClustersAggregateInfo,
    False,
    None))



class ColumnItem(VapiStruct):
    """
    Represents a column of the Grid

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    TYPE_STRING = "String"
    """


    """
    TYPE_NUMBER = "Number"
    """


    """
    TYPE_DATE = "Date"
    """


    """



    _canonical_to_pep_names = {
                            'column_identifier': 'column_identifier',
                            'drilldown_id': 'drilldown_id',
                            'field': 'field',
                            'hidden': 'hidden',
                            'label': 'label',
                            'navigation': 'navigation',
                            'render_configuration': 'render_configuration',
                            'sort_ascending': 'sort_ascending',
                            'sort_key': 'sort_key',
                            'tooltip': 'tooltip',
                            'type': 'type',
                            }

    def __init__(self,
                 column_identifier=None,
                 drilldown_id=None,
                 field=None,
                 hidden=None,
                 label=None,
                 navigation=None,
                 render_configuration=None,
                 sort_ascending=None,
                 sort_key=None,
                 tooltip=None,
                 type=None,
                ):
        """
        :type  column_identifier: :class:`str` or ``None``
        :param column_identifier: Identifies the column and used for fetching content upon an user
            click or drilldown. If column identifier is not provided, the
            column's data will not participate in searches and drilldowns.
        :type  drilldown_id: :class:`str` or ``None``
        :param drilldown_id: Id of drilldown widget, if any. Id should be a valid id of an
            existing widget.
        :type  field: :class:`str` or ``None``
        :param field: Field from which values of the column will be derived.
        :type  hidden: :class:`bool` or ``None``
        :param hidden: If set to true, hides the column
        :type  label: :class:`Label` or ``None``
        :param label: Label of the column.
        :type  navigation: :class:`str` or ``None``
        :param navigation: Hyperlink of the specified UI page that provides details. If
            drilldown_id is provided, then navigation cannot be used.
        :type  render_configuration: :class:`list` of :class:`RenderConfiguration` or ``None``
        :param render_configuration: Render configuration to be applied, if any.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, the value of the column are sorted in ascending order.
            Otherwise, in descending order.
        :type  sort_key: :class:`str` or ``None``
        :param sort_key: Sorting on column is based on the sort_key. sort_key represents the
            field in the output data on which sort is requested.
        :type  tooltip: :class:`list` of :class:`Tooltip` or ``None``
        :param tooltip: Multi-line text to be shown on tooltip while hovering over a cell
            in the grid.
        :type  type: :class:`str` or ``None``
        :param type: Possible values are: 
            
            * :attr:`ColumnItem.TYPE_STRING`
            * :attr:`ColumnItem.TYPE_NUMBER`
            * :attr:`ColumnItem.TYPE_DATE`
            
             Data type of the field.
        """
        self.column_identifier = column_identifier
        self.drilldown_id = drilldown_id
        self.field = field
        self.hidden = hidden
        self.label = label
        self.navigation = navigation
        self.render_configuration = render_configuration
        self.sort_ascending = sort_ascending
        self.sort_key = sort_key
        self.tooltip = tooltip
        self.type = type
        VapiStruct.__init__(self)


ColumnItem._set_binding_type(type.StructType(
    'com.vmware.nsx.model.column_item', {
        'column_identifier': type.OptionalType(type.StringType()),
        'drilldown_id': type.OptionalType(type.StringType()),
        'field': type.OptionalType(type.StringType()),
        'hidden': type.OptionalType(type.BooleanType()),
        'label': type.OptionalType(type.ReferenceType(__name__, 'Label')),
        'navigation': type.OptionalType(type.StringType()),
        'render_configuration': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'RenderConfiguration'))),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_key': type.OptionalType(type.StringType()),
        'tooltip': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tooltip'))),
        'type': type.OptionalType(type.StringType()),
    },
    ColumnItem,
    False,
    None))



class CommunityMatchExpression(VapiStruct):
    """
    Community match expression

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    OPERATOR_AND = "AND"
    """


    """



    _canonical_to_pep_names = {
                            'expression': 'expression',
                            'operator': 'operator',
                            }

    def __init__(self,
                 expression=None,
                 operator=None,
                ):
        """
        :type  expression: :class:`list` of :class:`CommunityMatchOperation` or ``None``
        :param expression: Array of community match operations
        :type  operator: :class:`str` or ``None``
        :param operator: Possible values are: 
            
            * :attr:`CommunityMatchExpression.OPERATOR_AND`
            
            Operator for evaluating community match expressions. AND logical
            AND operator
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.expression = expression
        self.operator = operator
        VapiStruct.__init__(self)


CommunityMatchExpression._set_binding_type(type.StructType(
    'com.vmware.nsx.model.community_match_expression', {
        'expression': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'CommunityMatchOperation'))),
        'operator': type.OptionalType(type.StringType()),
    },
    CommunityMatchExpression,
    False,
    None))



class CommunityMatchOperation(VapiStruct):
    """
    Community match operation

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    MATCH_OPERATOR_ANY = "MATCH_ANY"
    """


    """
    MATCH_OPERATOR_ALL = "MATCH_ALL"
    """


    """
    MATCH_OPERATOR_EXACT = "MATCH_EXACT"
    """


    """
    MATCH_OPERATOR_NONE = "MATCH_NONE"
    """


    """
    MATCH_OPERATOR_REGEX = "MATCH_REGEX"
    """


    """
    MATCH_OPERATOR_LARGE_COMMUNITY_REGEX = "MATCH_LARGE_COMMUNITY_REGEX"
    """


    """



    _canonical_to_pep_names = {
                            'community_list_id': 'community_list_id',
                            'match_operator': 'match_operator',
                            'regular_expression': 'regular_expression',
                            }

    def __init__(self,
                 community_list_id=None,
                 match_operator=None,
                 regular_expression=None,
                ):
        """
        :type  community_list_id: :class:`str` or ``None``
        :param community_list_id: ID of BGP community list. This value is not required when
            match_operator is MATCH_REGEX otherwise required.
        :type  match_operator: :class:`str` or ``None``
        :param match_operator: Possible values are: 
            
            * :attr:`CommunityMatchOperation.MATCH_OPERATOR_ANY`
            * :attr:`CommunityMatchOperation.MATCH_OPERATOR_ALL`
            * :attr:`CommunityMatchOperation.MATCH_OPERATOR_EXACT`
            * :attr:`CommunityMatchOperation.MATCH_OPERATOR_NONE`
            * :attr:`CommunityMatchOperation.MATCH_OPERATOR_REGEX`
            *
              :attr:`CommunityMatchOperation.MATCH_OPERATOR_LARGE_COMMUNITY_REGEX`
            
            Match operator for communities from provided community list id.
            MATCH_ANY will match any community MATCH_ALL will match all
            communities MATCH_EXACT will do exact match on community MATCH_NONE
            [operator not supported] will not match any community MATCH_REGEX
            will match normal communities by evaluating regular expression
            MATCH_LARGE_COMMUNITY_REGEX will match large communities by
            evaluating regular expression
        :type  regular_expression: :class:`str` or ``None``
        :param regular_expression: Regular expression to match BGP communities. If match_operator is
            MATCH_REGEX then this value must be specified.
        """
        self.community_list_id = community_list_id
        self.match_operator = match_operator
        self.regular_expression = regular_expression
        VapiStruct.__init__(self)


CommunityMatchOperation._set_binding_type(type.StructType(
    'com.vmware.nsx.model.community_match_operation', {
        'community_list_id': type.OptionalType(type.StringType()),
        'match_operator': type.OptionalType(type.StringType()),
        'regular_expression': type.OptionalType(type.StringType()),
    },
    CommunityMatchOperation,
    False,
    None))



class ComponentMigrationStatus(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATUS_SUCCESS = "SUCCESS"
    """


    """
    STATUS_FAILED = "FAILED"
    """


    """
    STATUS_IN_PROGRESS = "IN_PROGRESS"
    """


    """
    STATUS_NOT_STARTED = "NOT_STARTED"
    """


    """
    STATUS_PAUSED = "PAUSED"
    """


    """



    _canonical_to_pep_names = {
                            'can_skip': 'can_skip',
                            'component_type': 'component_type',
                            'details': 'details',
                            'percent_complete': 'percent_complete',
                            'status': 'status',
                            }

    def __init__(self,
                 can_skip=None,
                 component_type=None,
                 details=None,
                 percent_complete=None,
                 status=None,
                ):
        """
        :type  can_skip: :class:`bool` or ``None``
        :param can_skip: Can the migration of the remaining units in this component be
            skipped
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  component_type: :class:`str` or ``None``
        :param component_type: Component type for the migration status
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  details: :class:`str` or ``None``
        :param details: Details about the migration status
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  percent_complete: :class:`float` or ``None``
        :param percent_complete: Indicator of migration progress in percentage
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  status: :class:`str` or ``None``
        :param status: Possible values are: 
            
            * :attr:`ComponentMigrationStatus.STATUS_SUCCESS`
            * :attr:`ComponentMigrationStatus.STATUS_FAILED`
            * :attr:`ComponentMigrationStatus.STATUS_IN_PROGRESS`
            * :attr:`ComponentMigrationStatus.STATUS_NOT_STARTED`
            * :attr:`ComponentMigrationStatus.STATUS_PAUSED`
            
             Migration status of component
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.can_skip = can_skip
        self.component_type = component_type
        self.details = details
        self.percent_complete = percent_complete
        self.status = status
        VapiStruct.__init__(self)


ComponentMigrationStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.component_migration_status', {
        'can_skip': type.OptionalType(type.BooleanType()),
        'component_type': type.OptionalType(type.StringType()),
        'details': type.OptionalType(type.StringType()),
        'percent_complete': type.OptionalType(type.DoubleType()),
        'status': type.OptionalType(type.StringType()),
    },
    ComponentMigrationStatus,
    False,
    None))



class ComponentTargetVersion(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'component_type': 'component_type',
                            'target_version': 'target_version',
                            }

    def __init__(self,
                 component_type=None,
                 target_version=None,
                ):
        """
        :type  component_type: :class:`str` or ``None``
        :param component_type: 
        :type  target_version: :class:`str` or ``None``
        :param target_version: 
        """
        self.component_type = component_type
        self.target_version = target_version
        VapiStruct.__init__(self)


ComponentTargetVersion._set_binding_type(type.StructType(
    'com.vmware.nsx.model.component_target_version', {
        'component_type': type.OptionalType(type.StringType()),
        'target_version': type.OptionalType(type.StringType()),
    },
    ComponentTargetVersion,
    False,
    None))



class ComponentUpgradeChecksInfo(VapiStruct):
    """
    Meta-data of pre/post-upgrade checks for a component

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'component_type': 'component_type',
                            'post_upgrade_checks_info': 'post_upgrade_checks_info',
                            'pre_upgrade_checks_info': 'pre_upgrade_checks_info',
                            }

    def __init__(self,
                 component_type=None,
                 post_upgrade_checks_info=None,
                 pre_upgrade_checks_info=None,
                ):
        """
        :type  component_type: :class:`str` or ``None``
        :param component_type: Component type of the pre/post-upgrade checks
        :type  post_upgrade_checks_info: :class:`list` of :class:`UpgradeCheckInfo` or ``None``
        :param post_upgrade_checks_info: Collection of post-upgrade checks
        :type  pre_upgrade_checks_info: :class:`list` of :class:`UpgradeCheckInfo` or ``None``
        :param pre_upgrade_checks_info: Collection of pre-upgrade checks
        """
        self.component_type = component_type
        self.post_upgrade_checks_info = post_upgrade_checks_info
        self.pre_upgrade_checks_info = pre_upgrade_checks_info
        VapiStruct.__init__(self)


ComponentUpgradeChecksInfo._set_binding_type(type.StructType(
    'com.vmware.nsx.model.component_upgrade_checks_info', {
        'component_type': type.OptionalType(type.StringType()),
        'post_upgrade_checks_info': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'UpgradeCheckInfo'))),
        'pre_upgrade_checks_info': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'UpgradeCheckInfo'))),
    },
    ComponentUpgradeChecksInfo,
    False,
    None))



class ComponentUpgradeChecksInfoListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`ComponentUpgradeChecksInfo` or ``None``
        :param results: Collection of info of pre/post-upgrade checks for components
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


ComponentUpgradeChecksInfoListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.component_upgrade_checks_info_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ComponentUpgradeChecksInfo'))),
    },
    ComponentUpgradeChecksInfoListResult,
    False,
    None))



class ComponentUpgradeStatus(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATUS_SUCCESS = "SUCCESS"
    """


    """
    STATUS_FAILED = "FAILED"
    """


    """
    STATUS_IN_PROGRESS = "IN_PROGRESS"
    """


    """
    STATUS_NOT_STARTED = "NOT_STARTED"
    """


    """
    STATUS_PAUSING = "PAUSING"
    """


    """
    STATUS_PAUSED = "PAUSED"
    """


    """



    _canonical_to_pep_names = {
                            'can_skip': 'can_skip',
                            'component_type': 'component_type',
                            'current_version_node_summary': 'current_version_node_summary',
                            'details': 'details',
                            'node_count_at_target_version': 'node_count_at_target_version',
                            'percent_complete': 'percent_complete',
                            'pre_upgrade_status': 'pre_upgrade_status',
                            'status': 'status',
                            'target_component_version': 'target_component_version',
                            }

    def __init__(self,
                 can_skip=None,
                 component_type=None,
                 current_version_node_summary=None,
                 details=None,
                 node_count_at_target_version=None,
                 percent_complete=None,
                 pre_upgrade_status=None,
                 status=None,
                 target_component_version=None,
                ):
        """
        :type  can_skip: :class:`bool` or ``None``
        :param can_skip: Can the upgrade of the remaining units in this component be skipped
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  component_type: :class:`str` or ``None``
        :param component_type: Component type for the upgrade status
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  current_version_node_summary: :class:`NodeSummaryList` or ``None``
        :param current_version_node_summary: Mapping of current versions of nodes and counts of nodes at the
            respective versions.
        :type  details: :class:`str` or ``None``
        :param details: Details about the upgrade status
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  node_count_at_target_version: :class:`long` or ``None``
        :param node_count_at_target_version: Number of nodes of the type and at the component version format:
            int32
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  percent_complete: :class:`float` or ``None``
        :param percent_complete: Indicator of upgrade progress in percentage
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  pre_upgrade_status: :class:`UpgradeChecksExecutionStatus` or ``None``
        :param pre_upgrade_status: Pre-upgrade status of the component-type
        :type  status: :class:`str` or ``None``
        :param status: Possible values are: 
            
            * :attr:`ComponentUpgradeStatus.STATUS_SUCCESS`
            * :attr:`ComponentUpgradeStatus.STATUS_FAILED`
            * :attr:`ComponentUpgradeStatus.STATUS_IN_PROGRESS`
            * :attr:`ComponentUpgradeStatus.STATUS_NOT_STARTED`
            * :attr:`ComponentUpgradeStatus.STATUS_PAUSING`
            * :attr:`ComponentUpgradeStatus.STATUS_PAUSED`
            
             Upgrade status of component
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  target_component_version: :class:`str` or ``None``
        :param target_component_version: Target component version
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.can_skip = can_skip
        self.component_type = component_type
        self.current_version_node_summary = current_version_node_summary
        self.details = details
        self.node_count_at_target_version = node_count_at_target_version
        self.percent_complete = percent_complete
        self.pre_upgrade_status = pre_upgrade_status
        self.status = status
        self.target_component_version = target_component_version
        VapiStruct.__init__(self)


ComponentUpgradeStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.component_upgrade_status', {
        'can_skip': type.OptionalType(type.BooleanType()),
        'component_type': type.OptionalType(type.StringType()),
        'current_version_node_summary': type.OptionalType(type.ReferenceType(__name__, 'NodeSummaryList')),
        'details': type.OptionalType(type.StringType()),
        'node_count_at_target_version': type.OptionalType(type.IntegerType()),
        'percent_complete': type.OptionalType(type.DoubleType()),
        'pre_upgrade_status': type.OptionalType(type.ReferenceType(__name__, 'UpgradeChecksExecutionStatus')),
        'status': type.OptionalType(type.StringType()),
        'target_component_version': type.OptionalType(type.StringType()),
    },
    ComponentUpgradeStatus,
    False,
    None))



class ComputeCollection(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'cm_local_id': 'cm_local_id',
                            'external_id': 'external_id',
                            'origin_id': 'origin_id',
                            'origin_properties': 'origin_properties',
                            'origin_type': 'origin_type',
                            'owner_id': 'owner_id',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_last_sync_time': 'last_sync_time',
                            'description': 'description',
                            'display_name': 'display_name',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            }

    def __init__(self,
                 cm_local_id=None,
                 external_id=None,
                 origin_id=None,
                 origin_properties=None,
                 origin_type=None,
                 owner_id=None,
                 links=None,
                 schema=None,
                 self_=None,
                 last_sync_time=None,
                 description=None,
                 display_name=None,
                 resource_type=None,
                 tags=None,
                ):
        """
        :type  cm_local_id: :class:`str` or ``None``
        :param cm_local_id: Local Id of the compute collection in the Compute Manager
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  external_id: :class:`str` or ``None``
        :param external_id: External ID of the ComputeCollection in the source Compute manager,
            e.g. mo-ref in VC
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  origin_id: :class:`str` or ``None``
        :param origin_id: Id of the compute manager from where this Compute Collection was
            discovered
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  origin_properties: :class:`list` of :class:`KeyValuePair` or ``None``
        :param origin_properties: Key-Value map of additional specific properties of compute
            collection in the Compute Manager
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  origin_type: :class:`str` or ``None``
        :param origin_type: ComputeCollection type like VC_Cluster. Here the Compute Manager
            type prefix would help in differentiating similar named Compute
            Collection types from different Compute Managers
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  owner_id: :class:`str` or ``None``
        :param owner_id: Id of the owner of compute collection in the Compute Manager
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  last_sync_time: :class:`long` or ``None``
        :param last_sync_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  resource_type: :class:`str`
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        """
        self.cm_local_id = cm_local_id
        self.external_id = external_id
        self.origin_id = origin_id
        self.origin_properties = origin_properties
        self.origin_type = origin_type
        self.owner_id = owner_id
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.last_sync_time = last_sync_time
        self.description = description
        self.display_name = display_name
        self._resource_type = resource_type
        self.tags = tags
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

ComputeCollection._set_binding_type(type.StructType(
    'com.vmware.nsx.model.compute_collection', {
        'cm_local_id': type.OptionalType(type.StringType()),
        'external_id': type.OptionalType(type.StringType()),
        'origin_id': type.OptionalType(type.StringType()),
        'origin_properties': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'KeyValuePair'))),
        'origin_type': type.OptionalType(type.StringType()),
        'owner_id': type.OptionalType(type.StringType()),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_last_sync_time': type.OptionalType(type.IntegerType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
    },
    ComputeCollection,
    False,
    None))



class ComputeCollectionFabricTemplate(VapiStruct):
    """
    Compute collection fabric template

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'auto_install_nsx': 'auto_install_nsx',
                            'compute_collection_id': 'compute_collection_id',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 auto_install_nsx=None,
                 compute_collection_id=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  auto_install_nsx: :class:`bool` or ``None``
        :param auto_install_nsx: Indicates whether NSX components should be automcatically
            installed. When 'true' NSX components will be automatically
            installed on the new host added to compute collection.
        :type  compute_collection_id: :class:`str` or ``None``
        :param compute_collection_id: Associated compute collection id
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.auto_install_nsx = auto_install_nsx
        self.compute_collection_id = compute_collection_id
        VapiStruct.__init__(self)


ComputeCollectionFabricTemplate._set_binding_type(type.StructType(
    'com.vmware.nsx.model.compute_collection_fabric_template', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'auto_install_nsx': type.OptionalType(type.BooleanType()),
        'compute_collection_id': type.OptionalType(type.StringType()),
    },
    ComputeCollectionFabricTemplate,
    False,
    None))



class ComputeCollectionFabricTemplateListResult(VapiStruct):
    """
    List of compute collection fabric template

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`ComputeCollectionFabricTemplate` or ``None``
        :param results: List of compute collection fabric template
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


ComputeCollectionFabricTemplateListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.compute_collection_fabric_template_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ComputeCollectionFabricTemplate'))),
    },
    ComputeCollectionFabricTemplateListResult,
    False,
    None))



class ComputeCollectionListResult(VapiStruct):
    """
    Compute Collection list result

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`ComputeCollection` or ``None``
        :param results: Compute Collection list results
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


ComputeCollectionListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.compute_collection_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ComputeCollection'))),
    },
    ComputeCollectionListResult,
    False,
    None))



class ComputeCollectionNetworkInterfacesListResult(VapiStruct):
    """
    List of network interfaces for all discovered nodes in compute collection

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`DiscoveredNodeNetworkInterfaces` or ``None``
        :param results: List of discovered node with network interfaces
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


ComputeCollectionNetworkInterfacesListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.compute_collection_network_interfaces_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'DiscoveredNodeNetworkInterfaces'))),
    },
    ComputeCollectionNetworkInterfacesListResult,
    False,
    None))



class ComputeManager(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'credential': 'credential',
                            'origin_properties': 'origin_properties',
                            'origin_type': 'origin_type',
                            'reverse_proxy_https_port': 'reverse_proxy_https_port',
                            'server': 'server',
                            'set_as_oidc_provider': 'set_as_oidc_provider',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 credential=None,
                 origin_properties=None,
                 origin_type=None,
                 reverse_proxy_https_port=None,
                 server=None,
                 set_as_oidc_provider=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  credential: :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param credential: Login credentials for the compute manager
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`LoginCredential`. When methods return a value of this class
            as a return value, the attribute will contain all the attributes
            defined in :class:`LoginCredential`.
        :type  origin_properties: :class:`list` of :class:`KeyValuePair` or ``None``
        :param origin_properties: Key-Value map of additional specific properties of compute manager
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  origin_type: :class:`str` or ``None``
        :param origin_type: Compute manager type like vCenter
        :type  reverse_proxy_https_port: :class:`long` or ``None``
        :param reverse_proxy_https_port: Specifies https port of the reverse proxy to connect to compute
            manager. For e.g. In case of VC, this port can be retrieved from
            this config file /etc/vmware-rhttpproxy/config.xml. format: int64
        :type  server: :class:`str` or ``None``
        :param server: IP address or hostname of compute manager format: hostname-or-ip
        :type  set_as_oidc_provider: :class:`bool` or ``None``
        :param set_as_oidc_provider: If the compute manager is VC and need to set set as OIDC provider
            for NSX then this flag should be set as true. This is specific to
            wcp feature, should be enabled when this feature is being used.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.credential = credential
        self.origin_properties = origin_properties
        self.origin_type = origin_type
        self.reverse_proxy_https_port = reverse_proxy_https_port
        self.server = server
        self.set_as_oidc_provider = set_as_oidc_provider
        VapiStruct.__init__(self)


ComputeManager._set_binding_type(type.StructType(
    'com.vmware.nsx.model.compute_manager', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'credential': type.OptionalType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'LoginCredential')])),
        'origin_properties': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'KeyValuePair'))),
        'origin_type': type.OptionalType(type.StringType()),
        'reverse_proxy_https_port': type.OptionalType(type.IntegerType()),
        'server': type.OptionalType(type.StringType()),
        'set_as_oidc_provider': type.OptionalType(type.BooleanType()),
    },
    ComputeManager,
    False,
    None))



class ComputeManagerListResult(VapiStruct):
    """
    List of compute managers

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`ComputeManager` or ``None``
        :param results: List of compute managers
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


ComputeManagerListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.compute_manager_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ComputeManager'))),
    },
    ComputeManagerListResult,
    False,
    None))



class ComputeManagerStatus(VapiStruct):
    """
    Runtime status information of the compute manager

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    CONNECTION_STATUS_UP = "UP"
    """


    """
    CONNECTION_STATUS_DOWN = "DOWN"
    """


    """
    CONNECTION_STATUS_CONNECTING = "CONNECTING"
    """


    """
    REGISTRATION_STATUS_REGISTERED = "REGISTERED"
    """


    """
    REGISTRATION_STATUS_UNREGISTERED = "UNREGISTERED"
    """


    """
    REGISTRATION_STATUS_REGISTERING = "REGISTERING"
    """


    """



    _canonical_to_pep_names = {
                            'connection_errors': 'connection_errors',
                            'connection_status': 'connection_status',
                            'connection_status_details': 'connection_status_details',
                            'last_sync_time': 'last_sync_time',
                            'oidc_end_point_id': 'oidc_end_point_id',
                            'registration_errors': 'registration_errors',
                            'registration_status': 'registration_status',
                            'version': 'version',
                            }

    def __init__(self,
                 connection_errors=None,
                 connection_status=None,
                 connection_status_details=None,
                 last_sync_time=None,
                 oidc_end_point_id=None,
                 registration_errors=None,
                 registration_status=None,
                 version=None,
                ):
        """
        :type  connection_errors: :class:`list` of :class:`ErrorInfo` or ``None``
        :param connection_errors: Errors when connecting with compute manager
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  connection_status: :class:`str` or ``None``
        :param connection_status: Possible values are: 
            
            * :attr:`ComputeManagerStatus.CONNECTION_STATUS_UP`
            * :attr:`ComputeManagerStatus.CONNECTION_STATUS_DOWN`
            * :attr:`ComputeManagerStatus.CONNECTION_STATUS_CONNECTING`
            
             Status of connection with the compute manager
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  connection_status_details: :class:`str` or ``None``
        :param connection_status_details: Details about connection status
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_sync_time: :class:`long` or ``None``
        :param last_sync_time: Timestamp of the last successful update of Inventory, in epoch
            milliseconds. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  oidc_end_point_id: :class:`str` or ``None``
        :param oidc_end_point_id: If Compute manager is trusted as authorization server, then this Id
            will be Id of corresponding oidc end point.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  registration_errors: :class:`list` of :class:`ErrorInfo` or ``None``
        :param registration_errors: Errors when registering with compute manager
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  registration_status: :class:`str` or ``None``
        :param registration_status: Possible values are: 
            
            * :attr:`ComputeManagerStatus.REGISTRATION_STATUS_REGISTERED`
            * :attr:`ComputeManagerStatus.REGISTRATION_STATUS_UNREGISTERED`
            * :attr:`ComputeManagerStatus.REGISTRATION_STATUS_REGISTERING`
            
             Registration status of compute manager
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  version: :class:`str` or ``None``
        :param version: Version of the compute manager
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.connection_errors = connection_errors
        self.connection_status = connection_status
        self.connection_status_details = connection_status_details
        self.last_sync_time = last_sync_time
        self.oidc_end_point_id = oidc_end_point_id
        self.registration_errors = registration_errors
        self.registration_status = registration_status
        self.version = version
        VapiStruct.__init__(self)


ComputeManagerStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.compute_manager_status', {
        'connection_errors': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ErrorInfo'))),
        'connection_status': type.OptionalType(type.StringType()),
        'connection_status_details': type.OptionalType(type.StringType()),
        'last_sync_time': type.OptionalType(type.IntegerType()),
        'oidc_end_point_id': type.OptionalType(type.StringType()),
        'registration_errors': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ErrorInfo'))),
        'registration_status': type.OptionalType(type.StringType()),
        'version': type.OptionalType(type.StringType()),
    },
    ComputeManagerStatus,
    False,
    None))



class ComputeManagerTopology(VapiStruct):
    """
    Details where NVDS will be migrated to

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'compute_manager_id': 'compute_manager_id',
                            'dvswitch': 'dvswitch',
                            }

    def __init__(self,
                 compute_manager_id=None,
                 dvswitch=None,
                ):
        """
        :type  compute_manager_id: :class:`str` or ``None``
        :param compute_manager_id: Identifier of vcenter where VDS will be created
        :type  dvswitch: :class:`list` of :class:`VdsTopology` or ``None``
        :param dvswitch: Datacenter, VDS mapping
        """
        self.compute_manager_id = compute_manager_id
        self.dvswitch = dvswitch
        VapiStruct.__init__(self)


ComputeManagerTopology._set_binding_type(type.StructType(
    'com.vmware.nsx.model.compute_manager_topology', {
        'compute_manager_id': type.OptionalType(type.StringType()),
        'dvswitch': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'VdsTopology'))),
    },
    ComputeManagerTopology,
    False,
    None))



class ConditionalForwarderZone(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'source_ip': 'source_ip',
                            'upstream_servers': 'upstream_servers',
                            'domain_names': 'domain_names',
                            }

    def __init__(self,
                 source_ip=None,
                 upstream_servers=None,
                 domain_names=None,
                ):
        """
        :type  source_ip: :class:`str` or ``None``
        :param source_ip: The source ip used by the fowarder of the zone. If no source ip
            specified, the ip address of listener of the DNS forwarder will be
            used. format: ipv4
        :type  upstream_servers: :class:`list` of :class:`str` or ``None``
        :param upstream_servers: Ip address of the upstream DNS servers the DNS forwarder accesses.
            format: ipv4
        :type  domain_names: :class:`list` of :class:`str` or ``None``
        :param domain_names: A forwarder domain name should be a valid FQDN. If reverse lookup
            is needed for this zone, reverse lookup domain name like
            X.in-addr.arpa can be defined. Here the X represents a subnet.
        """
        self.source_ip = source_ip
        self.upstream_servers = upstream_servers
        self.domain_names = domain_names
        VapiStruct.__init__(self)


ConditionalForwarderZone._set_binding_type(type.StructType(
    'com.vmware.nsx.model.conditional_forwarder_zone', {
        'source_ip': type.OptionalType(type.StringType()),
        'upstream_servers': type.OptionalType(type.ListType(type.StringType())),
        'domain_names': type.OptionalType(type.ListType(type.StringType())),
    },
    ConditionalForwarderZone,
    False,
    None))



class ConfigurationState(VapiStruct):
    """
    Describes status of configuration of an entity

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATE_PENDING = "pending"
    """


    """
    STATE_IN_PROGRESS = "in_progress"
    """


    """
    STATE_SUCCESS = "success"
    """


    """
    STATE_FAILED = "failed"
    """


    """
    STATE_PARTIAL_SUCCESS = "partial_success"
    """


    """
    STATE_ORPHANED = "orphaned"
    """


    """
    STATE_UNKNOWN = "unknown"
    """


    """
    STATE_ERROR = "error"
    """


    """
    STATE_IN_SYNC = "in_sync"
    """


    """
    STATE_NOT_AVAILABLE = "NOT_AVAILABLE"
    """


    """
    STATE_VM_DEPLOYMENT_QUEUED = "VM_DEPLOYMENT_QUEUED"
    """


    """
    STATE_VM_DEPLOYMENT_IN_PROGRESS = "VM_DEPLOYMENT_IN_PROGRESS"
    """


    """
    STATE_VM_DEPLOYMENT_FAILED = "VM_DEPLOYMENT_FAILED"
    """


    """
    STATE_VM_POWER_ON_IN_PROGRESS = "VM_POWER_ON_IN_PROGRESS"
    """


    """
    STATE_VM_POWER_ON_FAILED = "VM_POWER_ON_FAILED"
    """


    """
    STATE_REGISTRATION_PENDING = "REGISTRATION_PENDING"
    """


    """
    STATE_NODE_NOT_READY = "NODE_NOT_READY"
    """


    """
    STATE_NODE_READY = "NODE_READY"
    """


    """
    STATE_VM_POWER_OFF_IN_PROGRESS = "VM_POWER_OFF_IN_PROGRESS"
    """


    """
    STATE_VM_POWER_OFF_FAILED = "VM_POWER_OFF_FAILED"
    """


    """
    STATE_VM_UNDEPLOY_IN_PROGRESS = "VM_UNDEPLOY_IN_PROGRESS"
    """


    """
    STATE_VM_UNDEPLOY_FAILED = "VM_UNDEPLOY_FAILED"
    """


    """
    STATE_VM_UNDEPLOY_SUCCESSFUL = "VM_UNDEPLOY_SUCCESSFUL"
    """


    """
    STATE_EDGE_CONFIG_ERROR = "EDGE_CONFIG_ERROR"
    """


    """
    STATE_VM_DEPLOYMENT_RESTARTED = "VM_DEPLOYMENT_RESTARTED"
    """


    """
    STATE_REGISTRATION_FAILED = "REGISTRATION_FAILED"
    """


    """
    STATE_TRANSPORT_NODE_SYNC_PENDING = "TRANSPORT_NODE_SYNC_PENDING"
    """


    """
    STATE_TRANSPORT_NODE_CONFIGURATION_MISSING = "TRANSPORT_NODE_CONFIGURATION_MISSING"
    """


    """
    STATE_EDGE_HARDWARE_NOT_SUPPORTED = "EDGE_HARDWARE_NOT_SUPPORTED"
    """


    """
    STATE_MULTIPLE_OVERLAY_TZS_NOT_SUPPORTED = "MULTIPLE_OVERLAY_TZS_NOT_SUPPORTED"
    """


    """
    STATE_TN_OVERLAY_TZ_IN_USE_BY_EDGE_CLUSTER = "TN_OVERLAY_TZ_IN_USE_BY_EDGE_CLUSTER"
    """


    """
    STATE_TZ_ENDPOINTS_NOT_SPECIFIED = "TZ_ENDPOINTS_NOT_SPECIFIED"
    """


    """
    STATE_NO_PNIC_PREPARED_IN_EDGE = "NO_PNIC_PREPARED_IN_EDGE"
    """


    """
    STATE_APPLIANCE_INTERNAL_ERROR = "APPLIANCE_INTERNAL_ERROR"
    """


    """
    STATE_VTEP_DHCP_NOT_SUPPORTED = "VTEP_DHCP_NOT_SUPPORTED"
    """


    """
    STATE_UNSUPPORTED_HOST_SWITCH_PROFILE = "UNSUPPORTED_HOST_SWITCH_PROFILE"
    """


    """
    STATE_UPLINK_HOST_SWITCH_PROFILE_NOT_SPECIFIED = "UPLINK_HOST_SWITCH_PROFILE_NOT_SPECIFIED"
    """


    """
    STATE_HOSTSWITCH_PROFILE_NOT_FOUND = "HOSTSWITCH_PROFILE_NOT_FOUND"
    """


    """
    STATE_LLDP_SEND_ENABLED_NOT_SUPPORTED = "LLDP_SEND_ENABLED_NOT_SUPPORTED"
    """


    """
    STATE_UNSUPPORTED_NAMED_TEAMING_POLICY = "UNSUPPORTED_NAMED_TEAMING_POLICY"
    """


    """
    STATE_LBSRCID_NOT_SUPPORTED_FOR_EDGE_VM = "LBSRCID_NOT_SUPPORTED_FOR_EDGE_VM"
    """


    """
    STATE_LACP_NOT_SUPPORTED_FOR_EDGE_VM = "LACP_NOT_SUPPORTED_FOR_EDGE_VM"
    """


    """
    STATE_STANDBY_UPLINKS_NOT_SUPPORTED_FOR_EDGE_VM = "STANDBY_UPLINKS_NOT_SUPPORTED_FOR_EDGE_VM"
    """


    """
    STATE_MULTIPLE_ACTIVE_UPLINKS_NOT_SUPPORTED_FOR_EDGE = "MULTIPLE_ACTIVE_UPLINKS_NOT_SUPPORTED_FOR_EDGE"
    """


    """
    STATE_UNSUPPORTED_LACP_LB_ALGO_FOR_NODE = "UNSUPPORTED_LACP_LB_ALGO_FOR_NODE"
    """


    """
    STATE_EDGE_NODE_VERSION_NOT_SUPPORTED = "EDGE_NODE_VERSION_NOT_SUPPORTED"
    """


    """
    STATE_NO_PNIC_SPECIFIED_IN_TN = "NO_PNIC_SPECIFIED_IN_TN"
    """


    """
    STATE_INVALID_PNIC_DEVICE_NAME = "INVALID_PNIC_DEVICE_NAME"
    """


    """
    STATE_TRANSPORT_NODE_READY = "TRANSPORT_NODE_READY"
    """


    """
    STATE_VM_NETWORK_EDIT_PENDING = "VM_NETWORK_EDIT_PENDING"
    """


    """
    STATE_UNSUPPORTED_DEFAULT_TEAMING_POLICY = "UNSUPPORTED_DEFAULT_TEAMING_POLICY"
    """


    """
    STATE_MPA_DISCONNECTED = "MPA_DISCONNECTED"
    """


    """
    STATE_VM_RENAME_PENDING = "VM_RENAME_PENDING"
    """


    """
    STATE_VM_CONFIG_EDIT_PENDING = "VM_CONFIG_EDIT_PENDING"
    """


    """
    STATE_VM_NETWORK_EDIT_FAILED = "VM_NETWORK_EDIT_FAILED"
    """


    """
    STATE_VM_RENAME_FAILED = "VM_RENAME_FAILED"
    """


    """
    STATE_VM_CONFIG_EDIT_FAILED = "VM_CONFIG_EDIT_FAILED"
    """


    """
    STATE_VM_CONFIG_DISCREPANCY = "VM_CONFIG_DISCREPANCY"
    """


    """
    STATE_VM_NODE_REFRESH_FAILED = "VM_NODE_REFRESH_FAILED"
    """


    """
    STATE_VM_PLACEMENT_REFRESH_FAILED = "VM_PLACEMENT_REFRESH_FAILED"
    """


    """
    STATE_REGISTRATION_TIMEDOUT = "REGISTRATION_TIMEDOUT"
    """


    """



    _canonical_to_pep_names = {
                            'details': 'details',
                            'failure_code': 'failure_code',
                            'failure_message': 'failure_message',
                            'state': 'state',
                            }

    def __init__(self,
                 details=None,
                 failure_code=None,
                 failure_message=None,
                 state=None,
                ):
        """
        :type  details: :class:`list` of :class:`ConfigurationStateElement` or ``None``
        :param details: Array of configuration state of various sub systems
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  failure_code: :class:`long` or ``None``
        :param failure_code: Error code format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  failure_message: :class:`str` or ``None``
        :param failure_message: Error message in case of failure
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  state: :class:`str` or ``None``
        :param state: Possible values are: 
            
            * :attr:`ConfigurationState.STATE_PENDING`
            * :attr:`ConfigurationState.STATE_IN_PROGRESS`
            * :attr:`ConfigurationState.STATE_SUCCESS`
            * :attr:`ConfigurationState.STATE_FAILED`
            * :attr:`ConfigurationState.STATE_PARTIAL_SUCCESS`
            * :attr:`ConfigurationState.STATE_ORPHANED`
            * :attr:`ConfigurationState.STATE_UNKNOWN`
            * :attr:`ConfigurationState.STATE_ERROR`
            * :attr:`ConfigurationState.STATE_IN_SYNC`
            * :attr:`ConfigurationState.STATE_NOT_AVAILABLE`
            * :attr:`ConfigurationState.STATE_VM_DEPLOYMENT_QUEUED`
            * :attr:`ConfigurationState.STATE_VM_DEPLOYMENT_IN_PROGRESS`
            * :attr:`ConfigurationState.STATE_VM_DEPLOYMENT_FAILED`
            * :attr:`ConfigurationState.STATE_VM_POWER_ON_IN_PROGRESS`
            * :attr:`ConfigurationState.STATE_VM_POWER_ON_FAILED`
            * :attr:`ConfigurationState.STATE_REGISTRATION_PENDING`
            * :attr:`ConfigurationState.STATE_NODE_NOT_READY`
            * :attr:`ConfigurationState.STATE_NODE_READY`
            * :attr:`ConfigurationState.STATE_VM_POWER_OFF_IN_PROGRESS`
            * :attr:`ConfigurationState.STATE_VM_POWER_OFF_FAILED`
            * :attr:`ConfigurationState.STATE_VM_UNDEPLOY_IN_PROGRESS`
            * :attr:`ConfigurationState.STATE_VM_UNDEPLOY_FAILED`
            * :attr:`ConfigurationState.STATE_VM_UNDEPLOY_SUCCESSFUL`
            * :attr:`ConfigurationState.STATE_EDGE_CONFIG_ERROR`
            * :attr:`ConfigurationState.STATE_VM_DEPLOYMENT_RESTARTED`
            * :attr:`ConfigurationState.STATE_REGISTRATION_FAILED`
            * :attr:`ConfigurationState.STATE_TRANSPORT_NODE_SYNC_PENDING`
            *
              :attr:`ConfigurationState.STATE_TRANSPORT_NODE_CONFIGURATION_MISSING`
            * :attr:`ConfigurationState.STATE_EDGE_HARDWARE_NOT_SUPPORTED`
            *
              :attr:`ConfigurationState.STATE_MULTIPLE_OVERLAY_TZS_NOT_SUPPORTED`
            *
              :attr:`ConfigurationState.STATE_TN_OVERLAY_TZ_IN_USE_BY_EDGE_CLUSTER`
            * :attr:`ConfigurationState.STATE_TZ_ENDPOINTS_NOT_SPECIFIED`
            * :attr:`ConfigurationState.STATE_NO_PNIC_PREPARED_IN_EDGE`
            * :attr:`ConfigurationState.STATE_APPLIANCE_INTERNAL_ERROR`
            * :attr:`ConfigurationState.STATE_VTEP_DHCP_NOT_SUPPORTED`
            * :attr:`ConfigurationState.STATE_UNSUPPORTED_HOST_SWITCH_PROFILE`
            *
              :attr:`ConfigurationState.STATE_UPLINK_HOST_SWITCH_PROFILE_NOT_SPECIFIED`
            * :attr:`ConfigurationState.STATE_HOSTSWITCH_PROFILE_NOT_FOUND`
            * :attr:`ConfigurationState.STATE_LLDP_SEND_ENABLED_NOT_SUPPORTED`
            * :attr:`ConfigurationState.STATE_UNSUPPORTED_NAMED_TEAMING_POLICY`
            *
              :attr:`ConfigurationState.STATE_LBSRCID_NOT_SUPPORTED_FOR_EDGE_VM`
            * :attr:`ConfigurationState.STATE_LACP_NOT_SUPPORTED_FOR_EDGE_VM`
            *
              :attr:`ConfigurationState.STATE_STANDBY_UPLINKS_NOT_SUPPORTED_FOR_EDGE_VM`
            *
              :attr:`ConfigurationState.STATE_MULTIPLE_ACTIVE_UPLINKS_NOT_SUPPORTED_FOR_EDGE`
            *
              :attr:`ConfigurationState.STATE_UNSUPPORTED_LACP_LB_ALGO_FOR_NODE`
            * :attr:`ConfigurationState.STATE_EDGE_NODE_VERSION_NOT_SUPPORTED`
            * :attr:`ConfigurationState.STATE_NO_PNIC_SPECIFIED_IN_TN`
            * :attr:`ConfigurationState.STATE_INVALID_PNIC_DEVICE_NAME`
            * :attr:`ConfigurationState.STATE_TRANSPORT_NODE_READY`
            * :attr:`ConfigurationState.STATE_VM_NETWORK_EDIT_PENDING`
            *
              :attr:`ConfigurationState.STATE_UNSUPPORTED_DEFAULT_TEAMING_POLICY`
            * :attr:`ConfigurationState.STATE_MPA_DISCONNECTED`
            * :attr:`ConfigurationState.STATE_VM_RENAME_PENDING`
            * :attr:`ConfigurationState.STATE_VM_CONFIG_EDIT_PENDING`
            * :attr:`ConfigurationState.STATE_VM_NETWORK_EDIT_FAILED`
            * :attr:`ConfigurationState.STATE_VM_RENAME_FAILED`
            * :attr:`ConfigurationState.STATE_VM_CONFIG_EDIT_FAILED`
            * :attr:`ConfigurationState.STATE_VM_CONFIG_DISCREPANCY`
            * :attr:`ConfigurationState.STATE_VM_NODE_REFRESH_FAILED`
            * :attr:`ConfigurationState.STATE_VM_PLACEMENT_REFRESH_FAILED`
            * :attr:`ConfigurationState.STATE_REGISTRATION_TIMEDOUT`
            
            Gives details of state of desired configuration. Additional enums
            with more details on progress/success/error states are sent for
            edge node. The success states are NODE_READY and
            TRANSPORT_NODE_READY, pending states are {VM_DEPLOYMENT_QUEUED,
            VM_DEPLOYMENT_IN_PROGRESS, REGISTRATION_PENDING} and other values
            indicate failures. \"in_sync\" state indicates that the desired
            configuration has been received by the host to which it applies,
            but is not yet in effect. When the configuration is actually in
            effect, the state will change to \"success\". Please note, failed
            state is deprecated.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.details = details
        self.failure_code = failure_code
        self.failure_message = failure_message
        self.state = state
        VapiStruct.__init__(self)


ConfigurationState._set_binding_type(type.StructType(
    'com.vmware.nsx.model.configuration_state', {
        'details': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ConfigurationStateElement'))),
        'failure_code': type.OptionalType(type.IntegerType()),
        'failure_message': type.OptionalType(type.StringType()),
        'state': type.OptionalType(type.StringType()),
    },
    ConfigurationState,
    False,
    None))



class ConfigurationStateElement(VapiStruct):
    """
    Describes status of configuration of an entity

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATE_IN_PROGRESS = "in_progress"
    """


    """
    STATE_SUCCESS = "success"
    """


    """
    STATE_FAILED = "failed"
    """


    """
    STATE_PARTIAL_SUCCESS = "partial_success"
    """


    """
    STATE_IN_SYNC = "in_sync"
    """


    """
    STATE_VM_DEPLOYMENT_FAILED = "VM_DEPLOYMENT_FAILED"
    """


    """
    STATE_VM_POWER_ON_FAILED = "VM_POWER_ON_FAILED"
    """


    """
    STATE_VM_POWER_OFF_FAILED = "VM_POWER_OFF_FAILED"
    """


    """
    STATE_VM_UNDEPLOY_FAILED = "VM_UNDEPLOY_FAILED"
    """


    """
    STATE_EDGE_CONFIG_ERROR = "EDGE_CONFIG_ERROR"
    """


    """
    STATE_REGISTRATION_FAILED = "REGISTRATION_FAILED"
    """


    """
    STATE_TRANSPORT_NODE_CONFIGURATION_MISSING = "TRANSPORT_NODE_CONFIGURATION_MISSING"
    """


    """
    STATE_EDGE_HARDWARE_NOT_SUPPORTED = "EDGE_HARDWARE_NOT_SUPPORTED"
    """


    """
    STATE_MULTIPLE_OVERLAY_TZS_NOT_SUPPORTED = "MULTIPLE_OVERLAY_TZS_NOT_SUPPORTED"
    """


    """
    STATE_TN_OVERLAY_TZ_IN_USE_BY_EDGE_CLUSTER = "TN_OVERLAY_TZ_IN_USE_BY_EDGE_CLUSTER"
    """


    """
    STATE_TZ_ENDPOINTS_NOT_SPECIFIED = "TZ_ENDPOINTS_NOT_SPECIFIED"
    """


    """
    STATE_NO_PNIC_PREPARED_IN_EDGE = "NO_PNIC_PREPARED_IN_EDGE"
    """


    """
    STATE_APPLIANCE_INTERNAL_ERROR = "APPLIANCE_INTERNAL_ERROR"
    """


    """
    STATE_VTEP_DHCP_NOT_SUPPORTED = "VTEP_DHCP_NOT_SUPPORTED"
    """


    """
    STATE_UNSUPPORTED_HOST_SWITCH_PROFILE = "UNSUPPORTED_HOST_SWITCH_PROFILE"
    """


    """
    STATE_UPLINK_HOST_SWITCH_PROFILE_NOT_SPECIFIED = "UPLINK_HOST_SWITCH_PROFILE_NOT_SPECIFIED"
    """


    """
    STATE_HOSTSWITCH_PROFILE_NOT_FOUND = "HOSTSWITCH_PROFILE_NOT_FOUND"
    """


    """
    STATE_LLDP_SEND_ENABLED_NOT_SUPPORTED = "LLDP_SEND_ENABLED_NOT_SUPPORTED"
    """


    """
    STATE_UNSUPPORTED_NAMED_TEAMING_POLICY = "UNSUPPORTED_NAMED_TEAMING_POLICY"
    """


    """
    STATE_LBSRCID_NOT_SUPPORTED_FOR_EDGE_VM = "LBSRCID_NOT_SUPPORTED_FOR_EDGE_VM"
    """


    """
    STATE_LACP_NOT_SUPPORTED_FOR_EDGE_VM = "LACP_NOT_SUPPORTED_FOR_EDGE_VM"
    """


    """
    STATE_STANDBY_UPLINKS_NOT_SUPPORTED_FOR_EDGE_VM = "STANDBY_UPLINKS_NOT_SUPPORTED_FOR_EDGE_VM"
    """


    """
    STATE_MULTIPLE_ACTIVE_UPLINKS_NOT_SUPPORTED_FOR_EDGE = "MULTIPLE_ACTIVE_UPLINKS_NOT_SUPPORTED_FOR_EDGE"
    """


    """
    STATE_UNSUPPORTED_LACP_LB_ALGO_FOR_NODE = "UNSUPPORTED_LACP_LB_ALGO_FOR_NODE"
    """


    """
    STATE_EDGE_NODE_VERSION_NOT_SUPPORTED = "EDGE_NODE_VERSION_NOT_SUPPORTED"
    """


    """
    STATE_NO_PNIC_SPECIFIED_IN_TN = "NO_PNIC_SPECIFIED_IN_TN"
    """


    """
    STATE_INVALID_PNIC_DEVICE_NAME = "INVALID_PNIC_DEVICE_NAME"
    """


    """
    STATE_UNSUPPORTED_DEFAULT_TEAMING_POLICY = "UNSUPPORTED_DEFAULT_TEAMING_POLICY"
    """


    """
    STATE_MPA_DISCONNECTED = "MPA_DISCONNECTED"
    """


    """
    STATE_VM_NETWORK_EDIT_PENDING = "VM_NETWORK_EDIT_PENDING"
    """


    """
    STATE_VM_RENAME_PENDING = "VM_RENAME_PENDING"
    """


    """
    STATE_VM_CONFIG_EDIT_PENDING = "VM_CONFIG_EDIT_PENDING"
    """


    """
    STATE_VM_NETWORK_EDIT_FAILED = "VM_NETWORK_EDIT_FAILED"
    """


    """
    STATE_VM_RENAME_FAILED = "VM_RENAME_FAILED"
    """


    """
    STATE_VM_CONFIG_EDIT_FAILED = "VM_CONFIG_EDIT_FAILED"
    """


    """
    STATE_VM_CONFIG_DISCREPANCY = "VM_CONFIG_DISCREPANCY"
    """


    """
    STATE_VM_NODE_REFRESH_FAILED = "VM_NODE_REFRESH_FAILED"
    """


    """
    STATE_VM_PLACEMENT_REFRESH_FAILED = "VM_PLACEMENT_REFRESH_FAILED"
    """


    """
    STATE_NOT_AVAILABLE = "NOT_AVAILABLE"
    """


    """
    STATE_REGISTRATION_TIMEDOUT = "REGISTRATION_TIMEDOUT"
    """


    """
    STATE_PENDING = "pending"
    """


    """
    STATE_ORPHANED = "orphaned"
    """


    """
    STATE_UNKNOWN = "unknown"
    """


    """
    STATE_ERROR = "error"
    """


    """



    _canonical_to_pep_names = {
                            'failure_code': 'failure_code',
                            'failure_message': 'failure_message',
                            'state': 'state',
                            'sub_system_address': 'sub_system_address',
                            'sub_system_id': 'sub_system_id',
                            'sub_system_name': 'sub_system_name',
                            'sub_system_type': 'sub_system_type',
                            }

    def __init__(self,
                 failure_code=None,
                 failure_message=None,
                 state=None,
                 sub_system_address=None,
                 sub_system_id=None,
                 sub_system_name=None,
                 sub_system_type=None,
                ):
        """
        :type  failure_code: :class:`long` or ``None``
        :param failure_code: Error code format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  failure_message: :class:`str` or ``None``
        :param failure_message: Error message in case of failure
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  state: :class:`str` or ``None``
        :param state: Possible values are: 
            
            * :attr:`ConfigurationStateElement.STATE_IN_PROGRESS`
            * :attr:`ConfigurationStateElement.STATE_SUCCESS`
            * :attr:`ConfigurationStateElement.STATE_FAILED`
            * :attr:`ConfigurationStateElement.STATE_PARTIAL_SUCCESS`
            * :attr:`ConfigurationStateElement.STATE_IN_SYNC`
            * :attr:`ConfigurationStateElement.STATE_VM_DEPLOYMENT_FAILED`
            * :attr:`ConfigurationStateElement.STATE_VM_POWER_ON_FAILED`
            * :attr:`ConfigurationStateElement.STATE_VM_POWER_OFF_FAILED`
            * :attr:`ConfigurationStateElement.STATE_VM_UNDEPLOY_FAILED`
            * :attr:`ConfigurationStateElement.STATE_EDGE_CONFIG_ERROR`
            * :attr:`ConfigurationStateElement.STATE_REGISTRATION_FAILED`
            *
              :attr:`ConfigurationStateElement.STATE_TRANSPORT_NODE_CONFIGURATION_MISSING`
            *
              :attr:`ConfigurationStateElement.STATE_EDGE_HARDWARE_NOT_SUPPORTED`
            *
              :attr:`ConfigurationStateElement.STATE_MULTIPLE_OVERLAY_TZS_NOT_SUPPORTED`
            *
              :attr:`ConfigurationStateElement.STATE_TN_OVERLAY_TZ_IN_USE_BY_EDGE_CLUSTER`
            *
              :attr:`ConfigurationStateElement.STATE_TZ_ENDPOINTS_NOT_SPECIFIED`
            * :attr:`ConfigurationStateElement.STATE_NO_PNIC_PREPARED_IN_EDGE`
            * :attr:`ConfigurationStateElement.STATE_APPLIANCE_INTERNAL_ERROR`
            * :attr:`ConfigurationStateElement.STATE_VTEP_DHCP_NOT_SUPPORTED`
            *
              :attr:`ConfigurationStateElement.STATE_UNSUPPORTED_HOST_SWITCH_PROFILE`
            *
              :attr:`ConfigurationStateElement.STATE_UPLINK_HOST_SWITCH_PROFILE_NOT_SPECIFIED`
            *
              :attr:`ConfigurationStateElement.STATE_HOSTSWITCH_PROFILE_NOT_FOUND`
            *
              :attr:`ConfigurationStateElement.STATE_LLDP_SEND_ENABLED_NOT_SUPPORTED`
            *
              :attr:`ConfigurationStateElement.STATE_UNSUPPORTED_NAMED_TEAMING_POLICY`
            *
              :attr:`ConfigurationStateElement.STATE_LBSRCID_NOT_SUPPORTED_FOR_EDGE_VM`
            *
              :attr:`ConfigurationStateElement.STATE_LACP_NOT_SUPPORTED_FOR_EDGE_VM`
            *
              :attr:`ConfigurationStateElement.STATE_STANDBY_UPLINKS_NOT_SUPPORTED_FOR_EDGE_VM`
            *
              :attr:`ConfigurationStateElement.STATE_MULTIPLE_ACTIVE_UPLINKS_NOT_SUPPORTED_FOR_EDGE`
            *
              :attr:`ConfigurationStateElement.STATE_UNSUPPORTED_LACP_LB_ALGO_FOR_NODE`
            *
              :attr:`ConfigurationStateElement.STATE_EDGE_NODE_VERSION_NOT_SUPPORTED`
            * :attr:`ConfigurationStateElement.STATE_NO_PNIC_SPECIFIED_IN_TN`
            * :attr:`ConfigurationStateElement.STATE_INVALID_PNIC_DEVICE_NAME`
            *
              :attr:`ConfigurationStateElement.STATE_UNSUPPORTED_DEFAULT_TEAMING_POLICY`
            * :attr:`ConfigurationStateElement.STATE_MPA_DISCONNECTED`
            * :attr:`ConfigurationStateElement.STATE_VM_NETWORK_EDIT_PENDING`
            * :attr:`ConfigurationStateElement.STATE_VM_RENAME_PENDING`
            * :attr:`ConfigurationStateElement.STATE_VM_CONFIG_EDIT_PENDING`
            * :attr:`ConfigurationStateElement.STATE_VM_NETWORK_EDIT_FAILED`
            * :attr:`ConfigurationStateElement.STATE_VM_RENAME_FAILED`
            * :attr:`ConfigurationStateElement.STATE_VM_CONFIG_EDIT_FAILED`
            * :attr:`ConfigurationStateElement.STATE_VM_CONFIG_DISCREPANCY`
            * :attr:`ConfigurationStateElement.STATE_VM_NODE_REFRESH_FAILED`
            *
              :attr:`ConfigurationStateElement.STATE_VM_PLACEMENT_REFRESH_FAILED`
            * :attr:`ConfigurationStateElement.STATE_NOT_AVAILABLE`
            * :attr:`ConfigurationStateElement.STATE_REGISTRATION_TIMEDOUT`
            * :attr:`ConfigurationStateElement.STATE_PENDING`
            * :attr:`ConfigurationStateElement.STATE_ORPHANED`
            * :attr:`ConfigurationStateElement.STATE_UNKNOWN`
            * :attr:`ConfigurationStateElement.STATE_ERROR`
            
             State of configuration on this sub system
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sub_system_address: :class:`str` or ``None``
        :param sub_system_address: URI of backing resource on sub system
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sub_system_id: :class:`str` or ``None``
        :param sub_system_id: Identifier of backing resource on sub system
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sub_system_name: :class:`str` or ``None``
        :param sub_system_name: Name of backing resource on sub system
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sub_system_type: :class:`str` or ``None``
        :param sub_system_type: Type of backing resource on sub system
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.failure_code = failure_code
        self.failure_message = failure_message
        self.state = state
        self.sub_system_address = sub_system_address
        self.sub_system_id = sub_system_id
        self.sub_system_name = sub_system_name
        self.sub_system_type = sub_system_type
        VapiStruct.__init__(self)


ConfigurationStateElement._set_binding_type(type.StructType(
    'com.vmware.nsx.model.configuration_state_element', {
        'failure_code': type.OptionalType(type.IntegerType()),
        'failure_message': type.OptionalType(type.StringType()),
        'state': type.OptionalType(type.StringType()),
        'sub_system_address': type.OptionalType(type.StringType()),
        'sub_system_id': type.OptionalType(type.StringType()),
        'sub_system_name': type.OptionalType(type.StringType()),
        'sub_system_type': type.OptionalType(type.StringType()),
    },
    ConfigurationStateElement,
    False,
    None))



class ConsolidatedEffectiveIPAddressMemberListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`EffectiveIPInfo` or ``None``
        :param results: Paged Collection of site wise consolidated effective ip addresses
            for the given NSGroup
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


ConsolidatedEffectiveIPAddressMemberListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.consolidated_effective_IP_address_member_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'EffectiveIPInfo'))),
    },
    ConsolidatedEffectiveIPAddressMemberListResult,
    False,
    None))



class ContainerApplication(VapiStruct):
    """
    Container application within a project.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "ContainerApplication"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    NETWORK_STATUS_HEALTHY = "HEALTHY"
    """


    """
    NETWORK_STATUS_UNHEALTHY = "UNHEALTHY"
    """


    """
    STATUS_UNKNOWN = "UNKNOWN"
    """


    """
    STATUS_HEALTHY = "HEALTHY"
    """


    """
    STATUS_UP = "UP"
    """


    """
    STATUS_DOWN = "DOWN"
    """


    """
    STATUS_DEGRADED = "DEGRADED"
    """


    """



    _canonical_to_pep_names = {
                            'container_cluster_id': 'container_cluster_id',
                            'container_project_id': 'container_project_id',
                            'external_id': 'external_id',
                            'network_errors': 'network_errors',
                            'network_status': 'network_status',
                            'origin_properties': 'origin_properties',
                            'status': 'status',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_last_sync_time': 'last_sync_time',
                            'description': 'description',
                            'display_name': 'display_name',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            }

    def __init__(self,
                 container_cluster_id=None,
                 container_project_id=None,
                 external_id=None,
                 network_errors=None,
                 network_status=None,
                 origin_properties=None,
                 status=None,
                 links=None,
                 schema=None,
                 self_=None,
                 last_sync_time=None,
                 description=None,
                 display_name=None,
                 resource_type='ContainerApplication',
                 tags=None,
                ):
        """
        :type  container_cluster_id: :class:`str` or ``None``
        :param container_cluster_id: Identifier of the container cluster this container application
            belongs to.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  container_project_id: :class:`str` or ``None``
        :param container_project_id: Identifier of the project which this container application belongs
            to.
        :type  external_id: :class:`str` or ``None``
        :param external_id: Identifier of the container application on container cluster e.g.
            PCF app id, k8s service id.
        :type  network_errors: :class:`list` of :class:`NetworkError` or ``None``
        :param network_errors: List of network errors related to container application.
        :type  network_status: :class:`str` or ``None``
        :param network_status: Possible values are: 
            
            * :attr:`ContainerApplication.NETWORK_STATUS_HEALTHY`
            * :attr:`ContainerApplication.NETWORK_STATUS_UNHEALTHY`
            
             Network status of container application.
        :type  origin_properties: :class:`list` of :class:`KeyValuePair` or ``None``
        :param origin_properties: Array of additional specific properties of container application in
            key-value format.
        :type  status: :class:`str` or ``None``
        :param status: Possible values are: 
            
            * :attr:`ContainerApplication.STATUS_UNKNOWN`
            * :attr:`ContainerApplication.STATUS_HEALTHY`
            * :attr:`ContainerApplication.STATUS_UP`
            * :attr:`ContainerApplication.STATUS_DOWN`
            * :attr:`ContainerApplication.STATUS_DEGRADED`
            
             Status of the container application.
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  last_sync_time: :class:`long` or ``None``
        :param last_sync_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  resource_type: :class:`str`
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        """
        self.container_cluster_id = container_cluster_id
        self.container_project_id = container_project_id
        self.external_id = external_id
        self.network_errors = network_errors
        self.network_status = network_status
        self.origin_properties = origin_properties
        self.status = status
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.last_sync_time = last_sync_time
        self.description = description
        self.display_name = display_name
        self._resource_type = resource_type
        self.tags = tags
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

ContainerApplication._set_binding_type(type.StructType(
    'com.vmware.nsx.model.container_application', {
        'container_cluster_id': type.OptionalType(type.StringType()),
        'container_project_id': type.OptionalType(type.StringType()),
        'external_id': type.OptionalType(type.StringType()),
        'network_errors': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NetworkError'))),
        'network_status': type.OptionalType(type.StringType()),
        'origin_properties': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'KeyValuePair'))),
        'status': type.OptionalType(type.StringType()),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_last_sync_time': type.OptionalType(type.IntegerType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
    },
    ContainerApplication,
    False,
    None))



class ContainerApplicationInstance(VapiStruct):
    """
    Container application instance within a project.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "ContainerApplicationInstance"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    NETWORK_STATUS_HEALTHY = "HEALTHY"
    """


    """
    NETWORK_STATUS_UNHEALTHY = "UNHEALTHY"
    """


    """
    STATUS_UNKNOWN = "UNKNOWN"
    """


    """
    STATUS_HEALTHY = "HEALTHY"
    """


    """
    STATUS_UP = "UP"
    """


    """
    STATUS_DOWN = "DOWN"
    """


    """
    STATUS_DEGRADED = "DEGRADED"
    """


    """



    _canonical_to_pep_names = {
                            'cluster_node_id': 'cluster_node_id',
                            'container_application_ids': 'container_application_ids',
                            'container_cluster_id': 'container_cluster_id',
                            'container_project_id': 'container_project_id',
                            'external_id': 'external_id',
                            'network_errors': 'network_errors',
                            'network_status': 'network_status',
                            'origin_properties': 'origin_properties',
                            'status': 'status',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_last_sync_time': 'last_sync_time',
                            'description': 'description',
                            'display_name': 'display_name',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            }

    def __init__(self,
                 cluster_node_id=None,
                 container_application_ids=None,
                 container_cluster_id=None,
                 container_project_id=None,
                 external_id=None,
                 network_errors=None,
                 network_status=None,
                 origin_properties=None,
                 status=None,
                 links=None,
                 schema=None,
                 self_=None,
                 last_sync_time=None,
                 description=None,
                 display_name=None,
                 resource_type='ContainerApplicationInstance',
                 tags=None,
                ):
        """
        :type  cluster_node_id: :class:`str` or ``None``
        :param cluster_node_id: Cluster node id where application instance is running.
        :type  container_application_ids: :class:`list` of :class:`str` or ``None``
        :param container_application_ids: List of identifiers of the container application.
        :type  container_cluster_id: :class:`str` or ``None``
        :param container_cluster_id: Identifier of the container cluster this application instance
            belongs to.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  container_project_id: :class:`str` or ``None``
        :param container_project_id: Identifier of the container project which this container
            application instance belongs to.
        :type  external_id: :class:`str` or ``None``
        :param external_id: Identifier of the container application instance on container
            cluster.
        :type  network_errors: :class:`list` of :class:`NetworkError` or ``None``
        :param network_errors: List of network errors related to container application instance.
        :type  network_status: :class:`str` or ``None``
        :param network_status: Possible values are: 
            
            * :attr:`ContainerApplicationInstance.NETWORK_STATUS_HEALTHY`
            * :attr:`ContainerApplicationInstance.NETWORK_STATUS_UNHEALTHY`
            
             Network status of container application instance.
        :type  origin_properties: :class:`list` of :class:`KeyValuePair` or ``None``
        :param origin_properties: Array of additional specific properties of container application
            instance in key-value format.
        :type  status: :class:`str` or ``None``
        :param status: Possible values are: 
            
            * :attr:`ContainerApplicationInstance.STATUS_UNKNOWN`
            * :attr:`ContainerApplicationInstance.STATUS_HEALTHY`
            * :attr:`ContainerApplicationInstance.STATUS_UP`
            * :attr:`ContainerApplicationInstance.STATUS_DOWN`
            * :attr:`ContainerApplicationInstance.STATUS_DEGRADED`
            
             Status of the container application instance.
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  last_sync_time: :class:`long` or ``None``
        :param last_sync_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  resource_type: :class:`str`
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        """
        self.cluster_node_id = cluster_node_id
        self.container_application_ids = container_application_ids
        self.container_cluster_id = container_cluster_id
        self.container_project_id = container_project_id
        self.external_id = external_id
        self.network_errors = network_errors
        self.network_status = network_status
        self.origin_properties = origin_properties
        self.status = status
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.last_sync_time = last_sync_time
        self.description = description
        self.display_name = display_name
        self._resource_type = resource_type
        self.tags = tags
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

ContainerApplicationInstance._set_binding_type(type.StructType(
    'com.vmware.nsx.model.container_application_instance', {
        'cluster_node_id': type.OptionalType(type.StringType()),
        'container_application_ids': type.OptionalType(type.ListType(type.StringType())),
        'container_cluster_id': type.OptionalType(type.StringType()),
        'container_project_id': type.OptionalType(type.StringType()),
        'external_id': type.OptionalType(type.StringType()),
        'network_errors': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NetworkError'))),
        'network_status': type.OptionalType(type.StringType()),
        'origin_properties': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'KeyValuePair'))),
        'status': type.OptionalType(type.StringType()),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_last_sync_time': type.OptionalType(type.IntegerType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
    },
    ContainerApplicationInstance,
    False,
    None))



class ContainerApplicationInstanceListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`ContainerApplicationInstance` or ``None``
        :param results: List of Container Applications
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


ContainerApplicationInstanceListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.container_application_instance_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ContainerApplicationInstance'))),
    },
    ContainerApplicationInstanceListResult,
    False,
    None))



class ContainerApplicationListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`ContainerApplication` or ``None``
        :param results: List of Container Applications
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


ContainerApplicationListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.container_application_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ContainerApplication'))),
    },
    ContainerApplicationListResult,
    False,
    None))



class ContainerCluster(VapiStruct):
    """
    Details of container cluster.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "ContainerCluster"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    CLUSTER_TYPE_PAS = "PAS"
    """


    """
    CLUSTER_TYPE_PKS = "PKS"
    """


    """
    CLUSTER_TYPE_KUBERNETES = "Kubernetes"
    """


    """
    CLUSTER_TYPE_OPENSHIFT = "Openshift"
    """


    """
    CLUSTER_TYPE_WCP = "WCP"
    """


    """
    CLUSTER_TYPE_WCP_GUEST = "WCP_Guest"
    """


    """
    CLUSTER_TYPE_OTHER = "Other"
    """


    """
    NETWORK_STATUS_HEALTHY = "HEALTHY"
    """


    """
    NETWORK_STATUS_UNHEALTHY = "UNHEALTHY"
    """


    """



    _canonical_to_pep_names = {
                            'cluster_type': 'cluster_type',
                            'external_id': 'external_id',
                            'infrastructure': 'infrastructure',
                            'network_errors': 'network_errors',
                            'network_status': 'network_status',
                            'origin_properties': 'origin_properties',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_last_sync_time': 'last_sync_time',
                            'description': 'description',
                            'display_name': 'display_name',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            }

    def __init__(self,
                 cluster_type=None,
                 external_id=None,
                 infrastructure=None,
                 network_errors=None,
                 network_status=None,
                 origin_properties=None,
                 links=None,
                 schema=None,
                 self_=None,
                 last_sync_time=None,
                 description=None,
                 display_name=None,
                 resource_type='ContainerCluster',
                 tags=None,
                ):
        """
        :type  cluster_type: :class:`str` or ``None``
        :param cluster_type: Possible values are: 
            
            * :attr:`ContainerCluster.CLUSTER_TYPE_PAS`
            * :attr:`ContainerCluster.CLUSTER_TYPE_PKS`
            * :attr:`ContainerCluster.CLUSTER_TYPE_KUBERNETES`
            * :attr:`ContainerCluster.CLUSTER_TYPE_OPENSHIFT`
            * :attr:`ContainerCluster.CLUSTER_TYPE_WCP`
            * :attr:`ContainerCluster.CLUSTER_TYPE_WCP_GUEST`
            * :attr:`ContainerCluster.CLUSTER_TYPE_OTHER`
            
            Type of the container cluster. In case of creating container
            cluster first time, it is expected to pass the valid cluster-type.
            In case of update, if there is no change in cluster-type, then this
            field can be omitted in the request.
        :type  external_id: :class:`str` or ``None``
        :param external_id: External identifier of the container cluster.
        :type  infrastructure: :class:`ContainerInfrastructureInfo` or ``None``
        :param infrastructure: Details of underlying infrastructure that hosts the container
            cluster. In case of creating container cluster first time, it is
            expected to pass the valid infrastructure. In case of update, if
            there is no change in cluster-type, then this field can be omitted
            in the request.
        :type  network_errors: :class:`list` of :class:`NetworkError` or ``None``
        :param network_errors: List of network errors related to container cluster.
        :type  network_status: :class:`str` or ``None``
        :param network_status: Possible values are: 
            
            * :attr:`ContainerCluster.NETWORK_STATUS_HEALTHY`
            * :attr:`ContainerCluster.NETWORK_STATUS_UNHEALTHY`
            
             Network status of container cluster.
        :type  origin_properties: :class:`list` of :class:`KeyValuePair` or ``None``
        :param origin_properties: Array of additional specific properties of container cluster in
            key-value format.
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  last_sync_time: :class:`long` or ``None``
        :param last_sync_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  resource_type: :class:`str`
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        """
        self.cluster_type = cluster_type
        self.external_id = external_id
        self.infrastructure = infrastructure
        self.network_errors = network_errors
        self.network_status = network_status
        self.origin_properties = origin_properties
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.last_sync_time = last_sync_time
        self.description = description
        self.display_name = display_name
        self._resource_type = resource_type
        self.tags = tags
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

ContainerCluster._set_binding_type(type.StructType(
    'com.vmware.nsx.model.container_cluster', {
        'cluster_type': type.OptionalType(type.StringType()),
        'external_id': type.OptionalType(type.StringType()),
        'infrastructure': type.OptionalType(type.ReferenceType(__name__, 'ContainerInfrastructureInfo')),
        'network_errors': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NetworkError'))),
        'network_status': type.OptionalType(type.StringType()),
        'origin_properties': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'KeyValuePair'))),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_last_sync_time': type.OptionalType(type.IntegerType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
    },
    ContainerCluster,
    False,
    None))



class ContainerClusterListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`ContainerCluster` or ``None``
        :param results: List of Container Clusters
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


ContainerClusterListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.container_cluster_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ContainerCluster'))),
    },
    ContainerClusterListResult,
    False,
    None))



class ContainerClusterNode(VapiStruct):
    """
    Details of container cluster node i.e. container host.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "ContainerClusterNode"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    NETWORK_STATUS_HEALTHY = "HEALTHY"
    """


    """
    NETWORK_STATUS_UNHEALTHY = "UNHEALTHY"
    """


    """



    _canonical_to_pep_names = {
                            'container_cluster_id': 'container_cluster_id',
                            'external_id': 'external_id',
                            'ip_addresses': 'ip_addresses',
                            'network_errors': 'network_errors',
                            'network_status': 'network_status',
                            'origin_properties': 'origin_properties',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_last_sync_time': 'last_sync_time',
                            'description': 'description',
                            'display_name': 'display_name',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            }

    def __init__(self,
                 container_cluster_id=None,
                 external_id=None,
                 ip_addresses=None,
                 network_errors=None,
                 network_status=None,
                 origin_properties=None,
                 links=None,
                 schema=None,
                 self_=None,
                 last_sync_time=None,
                 description=None,
                 display_name=None,
                 resource_type='ContainerClusterNode',
                 tags=None,
                ):
        """
        :type  container_cluster_id: :class:`str` or ``None``
        :param container_cluster_id: External identifier of the container cluster.
        :type  external_id: :class:`str` or ``None``
        :param external_id: External identifier of the container cluster node in K8S/PAS.
        :type  ip_addresses: :class:`list` of :class:`str` or ``None``
        :param ip_addresses: List of IP addresses of container cluster node. format: ip
        :type  network_errors: :class:`list` of :class:`NetworkError` or ``None``
        :param network_errors: List of network errors related to container cluster node.
        :type  network_status: :class:`str` or ``None``
        :param network_status: Possible values are: 
            
            * :attr:`ContainerClusterNode.NETWORK_STATUS_HEALTHY`
            * :attr:`ContainerClusterNode.NETWORK_STATUS_UNHEALTHY`
            
             Network status of container cluster node.
        :type  origin_properties: :class:`list` of :class:`KeyValuePair` or ``None``
        :param origin_properties: Array of additional specific properties of container cluster node
            in key-value format.
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  last_sync_time: :class:`long` or ``None``
        :param last_sync_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  resource_type: :class:`str`
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        """
        self.container_cluster_id = container_cluster_id
        self.external_id = external_id
        self.ip_addresses = ip_addresses
        self.network_errors = network_errors
        self.network_status = network_status
        self.origin_properties = origin_properties
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.last_sync_time = last_sync_time
        self.description = description
        self.display_name = display_name
        self._resource_type = resource_type
        self.tags = tags
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

ContainerClusterNode._set_binding_type(type.StructType(
    'com.vmware.nsx.model.container_cluster_node', {
        'container_cluster_id': type.OptionalType(type.StringType()),
        'external_id': type.OptionalType(type.StringType()),
        'ip_addresses': type.OptionalType(type.ListType(type.StringType())),
        'network_errors': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NetworkError'))),
        'network_status': type.OptionalType(type.StringType()),
        'origin_properties': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'KeyValuePair'))),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_last_sync_time': type.OptionalType(type.IntegerType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
    },
    ContainerClusterNode,
    False,
    None))



class ContainerClusterNodeListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`ContainerClusterNode` or ``None``
        :param results: List of container cluster nodes
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


ContainerClusterNodeListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.container_cluster_node_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ContainerClusterNode'))),
    },
    ContainerClusterNodeListResult,
    False,
    None))



class ContainerClusterStatus(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATUS_UNKNOWN = "UNKNOWN"
    """


    """
    STATUS_HEALTHY = "HEALTHY"
    """


    """
    STATUS_DOWN = "DOWN"
    """


    """
    STATUS_DEGRADED = "DEGRADED"
    """


    """



    _canonical_to_pep_names = {
                            'cluster_id': 'cluster_id',
                            'detail': 'detail',
                            'interval': 'interval',
                            'status': 'status',
                            }

    def __init__(self,
                 cluster_id=None,
                 detail=None,
                 interval=None,
                 status=None,
                ):
        """
        :type  cluster_id: :class:`str` or ``None``
        :param cluster_id: Identifier of the container cluster.
        :type  detail: :class:`str` or ``None``
        :param detail: Detail information on status.
        :type  interval: :class:`long` or ``None``
        :param interval: Display the cluster check interval in seconds. format: int32
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  status: :class:`str` or ``None``
        :param status: Possible values are: 
            
            * :attr:`ContainerClusterStatus.STATUS_UNKNOWN`
            * :attr:`ContainerClusterStatus.STATUS_HEALTHY`
            * :attr:`ContainerClusterStatus.STATUS_DOWN`
            * :attr:`ContainerClusterStatus.STATUS_DEGRADED`
            
             Display the container cluster status.
        """
        self.cluster_id = cluster_id
        self.detail = detail
        self.interval = interval
        self.status = status
        VapiStruct.__init__(self)


ContainerClusterStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.container_cluster_status', {
        'cluster_id': type.OptionalType(type.StringType()),
        'detail': type.OptionalType(type.StringType()),
        'interval': type.OptionalType(type.IntegerType()),
        'status': type.OptionalType(type.StringType()),
    },
    ContainerClusterStatus,
    False,
    None))



class ContainerClusterStatusList(VapiStruct):
    """
    List of the Container cluster

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`ContainerClusterSummary` or ``None``
        :param results: Container cluster list.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


ContainerClusterStatusList._set_binding_type(type.StructType(
    'com.vmware.nsx.model.container_cluster_status_list', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ContainerClusterSummary'))),
    },
    ContainerClusterStatusList,
    False,
    None))



class ContainerClusterSummary(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATUS_UNKNOWN = "UNKNOWN"
    """


    """
    STATUS_HEALTHY = "HEALTHY"
    """


    """
    STATUS_DOWN = "DOWN"
    """


    """
    STATUS_DEGRADED = "DEGRADED"
    """


    """
    TYPE_PAS = "PAS"
    """


    """
    TYPE_PKS = "PKS"
    """


    """
    TYPE_KUBERNETES = "Kubernetes"
    """


    """
    TYPE_OPENSHIFT = "Openshift"
    """


    """
    TYPE_WCP = "WCP"
    """


    """
    TYPE_OTHER = "Other"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'cluster_id': 'cluster_id',
                            'cluster_name': 'cluster_name',
                            'detail': 'detail',
                            'status': 'status',
                            'type': 'type',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 cluster_id=None,
                 cluster_name=None,
                 detail=None,
                 status=None,
                 type=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  cluster_id: :class:`str` or ``None``
        :param cluster_id: Identifier of the container cluster.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  cluster_name: :class:`str` or ``None``
        :param cluster_name: Display the container cluster name
        :type  detail: :class:`str` or ``None``
        :param detail: Detail information on status.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  status: :class:`str` or ``None``
        :param status: Possible values are: 
            
            * :attr:`ContainerClusterSummary.STATUS_UNKNOWN`
            * :attr:`ContainerClusterSummary.STATUS_HEALTHY`
            * :attr:`ContainerClusterSummary.STATUS_DOWN`
            * :attr:`ContainerClusterSummary.STATUS_DEGRADED`
            
             Display the container cluster status.
        :type  type: :class:`str` or ``None``
        :param type: Possible values are: 
            
            * :attr:`ContainerClusterSummary.TYPE_PAS`
            * :attr:`ContainerClusterSummary.TYPE_PKS`
            * :attr:`ContainerClusterSummary.TYPE_KUBERNETES`
            * :attr:`ContainerClusterSummary.TYPE_OPENSHIFT`
            * :attr:`ContainerClusterSummary.TYPE_WCP`
            * :attr:`ContainerClusterSummary.TYPE_OTHER`
            
             Container cluster type.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.cluster_id = cluster_id
        self.cluster_name = cluster_name
        self.detail = detail
        self.status = status
        self.type = type
        VapiStruct.__init__(self)


ContainerClusterSummary._set_binding_type(type.StructType(
    'com.vmware.nsx.model.container_cluster_summary', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'cluster_id': type.OptionalType(type.StringType()),
        'cluster_name': type.OptionalType(type.StringType()),
        'detail': type.OptionalType(type.StringType()),
        'status': type.OptionalType(type.StringType()),
        'type': type.OptionalType(type.StringType()),
    },
    ContainerClusterSummary,
    False,
    None))



class ContainerConfiguration(VapiStruct):
    """
    Represents a container to group widgets that belong to a common category or
    have a common purpose.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "ContainerConfiguration"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'header': 'header',
                            'labels': 'labels',
                            'layout': 'layout',
                            'navigation': 'navigation',
                            'widgets': 'widgets',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'datasources': 'datasources',
                            'default_filter_value': 'default_filter_value',
                            'drilldown_id': 'drilldown_id',
                            'filter': 'filter',
                            'filter_value_required': 'filter_value_required',
                            'footer': 'footer',
                            'icons': 'icons',
                            'is_drilldown': 'is_drilldown',
                            'legend': 'legend',
                            'shared': 'shared',
                            'span': 'span',
                            'weight': 'weight',
                            }

    def __init__(self,
                 header=None,
                 labels=None,
                 layout=None,
                 navigation=None,
                 widgets=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='ContainerConfiguration',
                 tags=None,
                 datasources=None,
                 default_filter_value=None,
                 drilldown_id=None,
                 filter=None,
                 filter_value_required=None,
                 footer=None,
                 icons=None,
                 is_drilldown=None,
                 legend=None,
                 shared=None,
                 span=None,
                 weight=None,
                ):
        """
        :type  header: :class:`Header` or ``None``
        :param header: 
        :type  labels: :class:`list` of :class:`Label` or ``None``
        :param labels: Labels for the container.
        :type  layout: :class:`Layout` or ``None``
        :param layout: Layout of widgets can be either vertical or horizontal. If layout
            is not specified a default horizontal layout is applied.
        :type  navigation: :class:`str` or ``None``
        :param navigation: Hyperlink of the specified UI page that provides details.
        :type  widgets: :class:`list` of :class:`WidgetItem` or ``None``
        :param widgets: If not specified, creates an empty container.
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Title of the widget. If display_name is omitted, the widget will be
            shown without a title.
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_LABELVALUECONFIGURATION`
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_DONUTCONFIGURATION`
            *
              :attr:`WidgetConfiguration.RESOURCE_TYPE_MULTIWIDGETCONFIGURATION`
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_CONTAINERCONFIGURATION`
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_STATSCONFIGURATION`
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_GRIDCONFIGURATION`
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_GRAPHCONFIGURATION`
            *
              :attr:`WidgetConfiguration.RESOURCE_TYPE_CUSTOMWIDGETCONFIGURATION`
            *
              :attr:`WidgetConfiguration.RESOURCE_TYPE_DROPDOWNFILTERWIDGETCONFIGURATION`
            
            Supported visualization types are LabelValueConfiguration,
            DonutConfiguration, GridConfiguration, StatsConfiguration,
            MultiWidgetConfiguration, GraphConfiguration,
            ContainerConfiguration, CustomWidgetConfiguration and
            DropdownFilterWidgetConfiguration.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  datasources: :class:`list` of :class:`Datasource` or ``None``
        :param datasources: The 'datasources' represent the sources from which data will be
            fetched. Currently, only NSX-API is supported as a 'default'
            datasource. An example of specifying 'default' datasource along
            with the urls to fetch data from is given at 'example_request'
            section of 'CreateWidgetConfiguration' API.
        :type  default_filter_value: :class:`list` of :class:`DefaultFilterValue` or ``None``
        :param default_filter_value: Default filter values to be passed to datasources. This will be
            used when the report is requested without filter values.
        :type  drilldown_id: :class:`str` or ``None``
        :param drilldown_id: Id of drilldown widget, if any. Id should be a valid id of an
            existing widget. A widget is considered as drilldown widget when it
            is associated with any other widget and provides more detailed
            information about any data item from the parent widget.
        :type  filter: :class:`str` or ``None``
        :param filter: Id of filter widget for subscription, if any. Id should be a valid
            id of an existing filter widget. Filter widget should be from the
            same view. Datasource URLs should have placeholder values equal to
            filter alias to accept the filter value on filter change.
        :type  filter_value_required: :class:`bool` or ``None``
        :param filter_value_required: Flag to indicate that widget will continue to work without filter
            value. If this flag is set to false then default_filter_value is
            manadatory.
        :type  footer: :class:`Footer` or ``None``
        :param footer: 
        :type  icons: :class:`list` of :class:`Icon` or ``None``
        :param icons: Icons to be applied at dashboard for widgets and UI elements.
        :type  is_drilldown: :class:`bool` or ``None``
        :param is_drilldown: Set to true if this widget should be used as a drilldown.
        :type  legend: :class:`Legend` or ``None``
        :param legend: Legend to be displayed. If legend is not needed, do not include it.
        :type  shared: :class:`bool` or ``None``
        :param shared: Please use the property 'shared' of View instead of this. The
            widgets of a shared view are visible to other users.
        :type  span: :class:`long` or ``None``
        :param span: Represents the horizontal span of the widget / container. format:
            int32
        :type  weight: :class:`long` or ``None``
        :param weight: Specify relavite weight in WidgetItem for placement in a view.
            Please see WidgetItem for details. format: int32
        """
        self.header = header
        self.labels = labels
        self.layout = layout
        self.navigation = navigation
        self.widgets = widgets
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        self.datasources = datasources
        self.default_filter_value = default_filter_value
        self.drilldown_id = drilldown_id
        self.filter = filter
        self.filter_value_required = filter_value_required
        self.footer = footer
        self.icons = icons
        self.is_drilldown = is_drilldown
        self.legend = legend
        self.shared = shared
        self.span = span
        self.weight = weight
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

ContainerConfiguration._set_binding_type(type.StructType(
    'com.vmware.nsx.model.container_configuration', {
        'header': type.OptionalType(type.ReferenceType(__name__, 'Header')),
        'labels': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Label'))),
        'layout': type.OptionalType(type.ReferenceType(__name__, 'Layout')),
        'navigation': type.OptionalType(type.StringType()),
        'widgets': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'WidgetItem'))),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'datasources': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Datasource'))),
        'default_filter_value': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'DefaultFilterValue'))),
        'drilldown_id': type.OptionalType(type.StringType()),
        'filter': type.OptionalType(type.StringType()),
        'filter_value_required': type.OptionalType(type.BooleanType()),
        'footer': type.OptionalType(type.ReferenceType(__name__, 'Footer')),
        'icons': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Icon'))),
        'is_drilldown': type.OptionalType(type.BooleanType()),
        'legend': type.OptionalType(type.ReferenceType(__name__, 'Legend')),
        'shared': type.OptionalType(type.BooleanType()),
        'span': type.OptionalType(type.IntegerType()),
        'weight': type.OptionalType(type.IntegerType()),
    },
    ContainerConfiguration,
    False,
    None))



class ContainerInfrastructureInfo(VapiStruct):
    """
    Details of infrastructure hosting the container cluster e.g. vSphere, AWS,
    VMC etc..

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    INFRA_TYPE_VSPHERE = "vSphere"
    """


    """
    INFRA_TYPE_AWS = "AWS"
    """


    """
    INFRA_TYPE_AZURE = "Azure"
    """


    """
    INFRA_TYPE_VMC = "VMC"
    """


    """
    INFRA_TYPE_KVM = "KVM"
    """


    """
    INFRA_TYPE_BAREMETAL = "Baremetal"
    """


    """



    _canonical_to_pep_names = {
                            'infra_type': 'infra_type',
                            }

    def __init__(self,
                 infra_type=None,
                ):
        """
        :type  infra_type: :class:`str` or ``None``
        :param infra_type: Possible values are: 
            
            * :attr:`ContainerInfrastructureInfo.INFRA_TYPE_VSPHERE`
            * :attr:`ContainerInfrastructureInfo.INFRA_TYPE_AWS`
            * :attr:`ContainerInfrastructureInfo.INFRA_TYPE_AZURE`
            * :attr:`ContainerInfrastructureInfo.INFRA_TYPE_VMC`
            * :attr:`ContainerInfrastructureInfo.INFRA_TYPE_KVM`
            * :attr:`ContainerInfrastructureInfo.INFRA_TYPE_BAREMETAL`
            
             Type of the infrastructure.
        """
        self.infra_type = infra_type
        VapiStruct.__init__(self)


ContainerInfrastructureInfo._set_binding_type(type.StructType(
    'com.vmware.nsx.model.container_infrastructure_info', {
        'infra_type': type.OptionalType(type.StringType()),
    },
    ContainerInfrastructureInfo,
    False,
    None))



class ContainerIngressPolicy(VapiStruct):
    """
    Details of Container Ingress Policy.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "ContainerIngressPolicy"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    NETWORK_STATUS_HEALTHY = "HEALTHY"
    """


    """
    NETWORK_STATUS_UNHEALTHY = "UNHEALTHY"
    """


    """



    _canonical_to_pep_names = {
                            'container_application_ids': 'container_application_ids',
                            'container_cluster_id': 'container_cluster_id',
                            'container_project_id': 'container_project_id',
                            'external_id': 'external_id',
                            'network_errors': 'network_errors',
                            'network_status': 'network_status',
                            'origin_properties': 'origin_properties',
                            'spec': 'spec',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_last_sync_time': 'last_sync_time',
                            'description': 'description',
                            'display_name': 'display_name',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            }

    def __init__(self,
                 container_application_ids=None,
                 container_cluster_id=None,
                 container_project_id=None,
                 external_id=None,
                 network_errors=None,
                 network_status=None,
                 origin_properties=None,
                 spec=None,
                 links=None,
                 schema=None,
                 self_=None,
                 last_sync_time=None,
                 description=None,
                 display_name=None,
                 resource_type='ContainerIngressPolicy',
                 tags=None,
                ):
        """
        :type  container_application_ids: :class:`list` of :class:`str` or ``None``
        :param container_application_ids: List of identifiers of the container application , on which ingress
            policy is applied. e.g. IDs of all services on which the ingress is
            applied in kubernetes.
        :type  container_cluster_id: :class:`str` or ``None``
        :param container_cluster_id: Identifier of the container cluster this ingress policy belongs to.
        :type  container_project_id: :class:`str` or ``None``
        :param container_project_id: Identifier of the project which this container ingress belongs to.
        :type  external_id: :class:`str` or ``None``
        :param external_id: Identifier of the container ingress policy.
        :type  network_errors: :class:`list` of :class:`NetworkError` or ``None``
        :param network_errors: List of network errors related to container ingress.
        :type  network_status: :class:`str` or ``None``
        :param network_status: Possible values are: 
            
            * :attr:`ContainerIngressPolicy.NETWORK_STATUS_HEALTHY`
            * :attr:`ContainerIngressPolicy.NETWORK_STATUS_UNHEALTHY`
            
             Network status of container ingress.
        :type  origin_properties: :class:`list` of :class:`KeyValuePair` or ``None``
        :param origin_properties: Array of additional specific properties of container ingress in
            key-value format.
        :type  spec: :class:`str` or ``None``
        :param spec: Container ingress policy specification.
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  last_sync_time: :class:`long` or ``None``
        :param last_sync_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  resource_type: :class:`str`
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        """
        self.container_application_ids = container_application_ids
        self.container_cluster_id = container_cluster_id
        self.container_project_id = container_project_id
        self.external_id = external_id
        self.network_errors = network_errors
        self.network_status = network_status
        self.origin_properties = origin_properties
        self.spec = spec
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.last_sync_time = last_sync_time
        self.description = description
        self.display_name = display_name
        self._resource_type = resource_type
        self.tags = tags
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

ContainerIngressPolicy._set_binding_type(type.StructType(
    'com.vmware.nsx.model.container_ingress_policy', {
        'container_application_ids': type.OptionalType(type.ListType(type.StringType())),
        'container_cluster_id': type.OptionalType(type.StringType()),
        'container_project_id': type.OptionalType(type.StringType()),
        'external_id': type.OptionalType(type.StringType()),
        'network_errors': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NetworkError'))),
        'network_status': type.OptionalType(type.StringType()),
        'origin_properties': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'KeyValuePair'))),
        'spec': type.OptionalType(type.StringType()),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_last_sync_time': type.OptionalType(type.IntegerType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
    },
    ContainerIngressPolicy,
    False,
    None))



class ContainerIngressPolicyListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`ContainerIngressPolicy` or ``None``
        :param results: List of Container Ingress Policy specs
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


ContainerIngressPolicyListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.container_ingress_policy_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ContainerIngressPolicy'))),
    },
    ContainerIngressPolicyListResult,
    False,
    None))



class ContainerNetworkPolicy(VapiStruct):
    """
    Network policy applied to container.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "ContainerNetworkPolicy"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    NETWORK_STATUS_HEALTHY = "HEALTHY"
    """


    """
    NETWORK_STATUS_UNHEALTHY = "UNHEALTHY"
    """


    """
    POLICY_TYPE_NETWORK_POLICY = "NETWORK_POLICY"
    """


    """
    POLICY_TYPE_ASG = "ASG"
    """


    """



    _canonical_to_pep_names = {
                            'container_cluster_id': 'container_cluster_id',
                            'container_project_id': 'container_project_id',
                            'external_id': 'external_id',
                            'network_errors': 'network_errors',
                            'network_status': 'network_status',
                            'origin_properties': 'origin_properties',
                            'policy_type': 'policy_type',
                            'spec': 'spec',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_last_sync_time': 'last_sync_time',
                            'description': 'description',
                            'display_name': 'display_name',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            }

    def __init__(self,
                 container_cluster_id=None,
                 container_project_id=None,
                 external_id=None,
                 network_errors=None,
                 network_status=None,
                 origin_properties=None,
                 policy_type=None,
                 spec=None,
                 links=None,
                 schema=None,
                 self_=None,
                 last_sync_time=None,
                 description=None,
                 display_name=None,
                 resource_type='ContainerNetworkPolicy',
                 tags=None,
                ):
        """
        :type  container_cluster_id: :class:`str` or ``None``
        :param container_cluster_id: Identifier of the container cluster this network policy belongs to.
        :type  container_project_id: :class:`str` or ``None``
        :param container_project_id: Identifier of the project which this network policy belongs to.
        :type  external_id: :class:`str` or ``None``
        :param external_id: Identifier of the container network policy.
        :type  network_errors: :class:`list` of :class:`NetworkError` or ``None``
        :param network_errors: List of network errors related to container network policy.
        :type  network_status: :class:`str` or ``None``
        :param network_status: Possible values are: 
            
            * :attr:`ContainerNetworkPolicy.NETWORK_STATUS_HEALTHY`
            * :attr:`ContainerNetworkPolicy.NETWORK_STATUS_UNHEALTHY`
            
             Network status of container network policy.
        :type  origin_properties: :class:`list` of :class:`KeyValuePair` or ``None``
        :param origin_properties: Array of additional specific properties of container network policy
            in key-value format.
        :type  policy_type: :class:`str` or ``None``
        :param policy_type: Possible values are: 
            
            * :attr:`ContainerNetworkPolicy.POLICY_TYPE_NETWORK_POLICY`
            * :attr:`ContainerNetworkPolicy.POLICY_TYPE_ASG`
            
             Type e.g. Network Policy, ASG.
        :type  spec: :class:`str` or ``None``
        :param spec: Container network policy specification.
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  last_sync_time: :class:`long` or ``None``
        :param last_sync_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  resource_type: :class:`str`
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        """
        self.container_cluster_id = container_cluster_id
        self.container_project_id = container_project_id
        self.external_id = external_id
        self.network_errors = network_errors
        self.network_status = network_status
        self.origin_properties = origin_properties
        self.policy_type = policy_type
        self.spec = spec
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.last_sync_time = last_sync_time
        self.description = description
        self.display_name = display_name
        self._resource_type = resource_type
        self.tags = tags
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

ContainerNetworkPolicy._set_binding_type(type.StructType(
    'com.vmware.nsx.model.container_network_policy', {
        'container_cluster_id': type.OptionalType(type.StringType()),
        'container_project_id': type.OptionalType(type.StringType()),
        'external_id': type.OptionalType(type.StringType()),
        'network_errors': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NetworkError'))),
        'network_status': type.OptionalType(type.StringType()),
        'origin_properties': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'KeyValuePair'))),
        'policy_type': type.OptionalType(type.StringType()),
        'spec': type.OptionalType(type.StringType()),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_last_sync_time': type.OptionalType(type.IntegerType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
    },
    ContainerNetworkPolicy,
    False,
    None))



class ContainerNetworkPolicyListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`ContainerNetworkPolicy` or ``None``
        :param results: List of Container Network Policy specs
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


ContainerNetworkPolicyListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.container_network_policy_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ContainerNetworkPolicy'))),
    },
    ContainerNetworkPolicyListResult,
    False,
    None))



class ContainerProject(VapiStruct):
    """
    Details of org/namespace within a container cluster.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "ContainerProject"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    NETWORK_STATUS_HEALTHY = "HEALTHY"
    """


    """
    NETWORK_STATUS_UNHEALTHY = "UNHEALTHY"
    """


    """



    _canonical_to_pep_names = {
                            'container_cluster_id': 'container_cluster_id',
                            'external_id': 'external_id',
                            'network_errors': 'network_errors',
                            'network_status': 'network_status',
                            'origin_properties': 'origin_properties',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_last_sync_time': 'last_sync_time',
                            'description': 'description',
                            'display_name': 'display_name',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            }

    def __init__(self,
                 container_cluster_id=None,
                 external_id=None,
                 network_errors=None,
                 network_status=None,
                 origin_properties=None,
                 links=None,
                 schema=None,
                 self_=None,
                 last_sync_time=None,
                 description=None,
                 display_name=None,
                 resource_type='ContainerProject',
                 tags=None,
                ):
        """
        :type  container_cluster_id: :class:`str` or ``None``
        :param container_cluster_id: Identifier of the container cluster to which this project/namespace
            belongs.
        :type  external_id: :class:`str` or ``None``
        :param external_id: External identifier of the container project.
        :type  network_errors: :class:`list` of :class:`NetworkError` or ``None``
        :param network_errors: List of network errors related to container project.
        :type  network_status: :class:`str` or ``None``
        :param network_status: Possible values are: 
            
            * :attr:`ContainerProject.NETWORK_STATUS_HEALTHY`
            * :attr:`ContainerProject.NETWORK_STATUS_UNHEALTHY`
            
             Network status of container project.
        :type  origin_properties: :class:`list` of :class:`KeyValuePair` or ``None``
        :param origin_properties: Array of additional specific properties of container project in
            key-value format.
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  last_sync_time: :class:`long` or ``None``
        :param last_sync_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  resource_type: :class:`str`
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        """
        self.container_cluster_id = container_cluster_id
        self.external_id = external_id
        self.network_errors = network_errors
        self.network_status = network_status
        self.origin_properties = origin_properties
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.last_sync_time = last_sync_time
        self.description = description
        self.display_name = display_name
        self._resource_type = resource_type
        self.tags = tags
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

ContainerProject._set_binding_type(type.StructType(
    'com.vmware.nsx.model.container_project', {
        'container_cluster_id': type.OptionalType(type.StringType()),
        'external_id': type.OptionalType(type.StringType()),
        'network_errors': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NetworkError'))),
        'network_status': type.OptionalType(type.StringType()),
        'origin_properties': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'KeyValuePair'))),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_last_sync_time': type.OptionalType(type.IntegerType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
    },
    ContainerProject,
    False,
    None))



class ContainerProjectListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`ContainerProject` or ``None``
        :param results: List of projects
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


ContainerProjectListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.container_project_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ContainerProject'))),
    },
    ContainerProjectListResult,
    False,
    None))



class ControlClusterNodeStatus(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    CONTROL_CLUSTER_STATUS_CONNECTED = "CONNECTED"
    """


    """
    CONTROL_CLUSTER_STATUS_DISCONNECTED = "DISCONNECTED"
    """


    """
    CONTROL_CLUSTER_STATUS_UNKNOWN = "UNKNOWN"
    """


    """



    _canonical_to_pep_names = {
                            'control_cluster_status': 'control_cluster_status',
                            'mgmt_connection_status': 'mgmt_connection_status',
                            }

    def __init__(self,
                 control_cluster_status=None,
                 mgmt_connection_status=None,
                ):
        """
        :type  control_cluster_status: :class:`str` or ``None``
        :param control_cluster_status: Possible values are: 
            
            * :attr:`ControlClusterNodeStatus.CONTROL_CLUSTER_STATUS_CONNECTED`
            *
              :attr:`ControlClusterNodeStatus.CONTROL_CLUSTER_STATUS_DISCONNECTED`
            * :attr:`ControlClusterNodeStatus.CONTROL_CLUSTER_STATUS_UNKNOWN`
            
             Status of this node's connection to the control cluster
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  mgmt_connection_status: :class:`MgmtConnStatus` or ``None``
        :param mgmt_connection_status: Status of this node's management plane connection
        """
        self.control_cluster_status = control_cluster_status
        self.mgmt_connection_status = mgmt_connection_status
        VapiStruct.__init__(self)


ControlClusterNodeStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.control_cluster_node_status', {
        'control_cluster_status': type.OptionalType(type.StringType()),
        'mgmt_connection_status': type.OptionalType(type.ReferenceType(__name__, 'MgmtConnStatus')),
    },
    ControlClusterNodeStatus,
    False,
    None))



class ControlClusteringConfig(VapiStruct):
    """
    Config for joining cluster nodes VMs to a control cluster

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "ControlClusteringConfig"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'join_to_existing_cluster': 'join_to_existing_cluster',
                            'shared_secret': 'shared_secret',
                            'clustering_type': 'clustering_type',
                            }

    def __init__(self,
                 join_to_existing_cluster=None,
                 shared_secret=None,
                 clustering_type='ControlClusteringConfig',
                ):
        """
        :type  join_to_existing_cluster: :class:`bool` or ``None``
        :param join_to_existing_cluster: Specifies whether or not the cluster node VM should try to join to
            the existing control cluster or initialize a new one. Only required
            in uncertainty case, i.e. when there are manually- deployed
            controllers that are registered but not connected to the cluster
            and no auto-deployed controllers are part of the cluster.
        :type  shared_secret: :class:`str` or ``None``
        :param shared_secret: Shared secret to be used when joining the cluster node VM to a
            control cluster or for initializing a new cluster with the VM. Must
            contain at least 4 unique characters and be at least 6 characters
            long.
        :type  clustering_type: :class:`str`
        :param clustering_type: Possible values are: 
            
            * :attr:`ClusteringConfig.CLUSTERING_TYPE_CONTROLCLUSTERINGCONFIG`
            
             Specifies the type of clustering config to be used.
        """
        self.join_to_existing_cluster = join_to_existing_cluster
        self.shared_secret = shared_secret
        self._clustering_type = clustering_type
        VapiStruct.__init__(self)

    @property
    def clustering_type(self):
        """
        Return the discriminator value
        """
        return self._clustering_type

ControlClusteringConfig._set_binding_type(type.StructType(
    'com.vmware.nsx.model.control_clustering_config', {
        'join_to_existing_cluster': type.OptionalType(type.BooleanType()),
        'shared_secret': type.OptionalType(type.StringType()),
        'clustering_type': type.StringType(),
    },
    ControlClusteringConfig,
    False,
    None))



class ControlConnStatus(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    FAILURE_STATUS_CONNECTION_REFUSED = "CONNECTION_REFUSED"
    """


    """
    FAILURE_STATUS_INCOMPLETE_HOST_CERT = "INCOMPLETE_HOST_CERT"
    """


    """
    FAILURE_STATUS_INCOMPLETE_CONTROLLER_CERT = "INCOMPLETE_CONTROLLER_CERT"
    """


    """
    FAILURE_STATUS_CONTROLLER_REJECTED_HOST_CERT = "CONTROLLER_REJECTED_HOST_CERT"
    """


    """
    FAILURE_STATUS_HOST_REJECTED_CONTROLLER_CERT = "HOST_REJECTED_CONTROLLER_CERT"
    """


    """
    FAILURE_STATUS_KEEP_ALIVE_TIMEOUT = "KEEP_ALIVE_TIMEOUT"
    """


    """
    FAILURE_STATUS_OTHER_SSL_ERROR = "OTHER_SSL_ERROR"
    """


    """
    FAILURE_STATUS_OTHER_ERROR = "OTHER_ERROR"
    """


    """
    STATUS_UP = "UP"
    """


    """
    STATUS_DOWN = "DOWN"
    """


    """



    _canonical_to_pep_names = {
                            'control_node_ip': 'control_node_ip',
                            'failure_status': 'failure_status',
                            'status': 'status',
                            }

    def __init__(self,
                 control_node_ip=None,
                 failure_status=None,
                 status=None,
                ):
        """
        :type  control_node_ip: :class:`str` or ``None``
        :param control_node_ip: IP address of the control Node.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  failure_status: :class:`str` or ``None``
        :param failure_status: Possible values are: 
            
            * :attr:`ControlConnStatus.FAILURE_STATUS_CONNECTION_REFUSED`
            * :attr:`ControlConnStatus.FAILURE_STATUS_INCOMPLETE_HOST_CERT`
            *
              :attr:`ControlConnStatus.FAILURE_STATUS_INCOMPLETE_CONTROLLER_CERT`
            *
              :attr:`ControlConnStatus.FAILURE_STATUS_CONTROLLER_REJECTED_HOST_CERT`
            *
              :attr:`ControlConnStatus.FAILURE_STATUS_HOST_REJECTED_CONTROLLER_CERT`
            * :attr:`ControlConnStatus.FAILURE_STATUS_KEEP_ALIVE_TIMEOUT`
            * :attr:`ControlConnStatus.FAILURE_STATUS_OTHER_SSL_ERROR`
            * :attr:`ControlConnStatus.FAILURE_STATUS_OTHER_ERROR`
            
            Failure status of the control Node for e.g
            CONNECTION_REFUSED,INCOMPLETE_HOST_CERT.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  status: :class:`str` or ``None``
        :param status: Possible values are: 
            
            * :attr:`ControlConnStatus.STATUS_UP`
            * :attr:`ControlConnStatus.STATUS_DOWN`
            
             Status of the control Node for e.g UP, DOWN.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.control_node_ip = control_node_ip
        self.failure_status = failure_status
        self.status = status
        VapiStruct.__init__(self)


ControlConnStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.control_conn_status', {
        'control_node_ip': type.OptionalType(type.StringType()),
        'failure_status': type.OptionalType(type.StringType()),
        'status': type.OptionalType(type.StringType()),
    },
    ControlConnStatus,
    False,
    None))



class ControllerClusterRoleConfig(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    TYPE_MANAGEMENTCLUSTERROLECONFIG = "ManagementClusterRoleConfig"
    """


    """
    TYPE_CONTROLLERCLUSTERROLECONFIG = "ControllerClusterRoleConfig"
    """


    """



    _canonical_to_pep_names = {
                            'type': 'type',
                            'control_cluster_listen_addr': 'control_cluster_listen_addr',
                            'control_plane_listen_addr': 'control_plane_listen_addr',
                            'host_msg_client_info': 'host_msg_client_info',
                            'mpa_msg_client_info': 'mpa_msg_client_info',
                            }

    def __init__(self,
                 type=None,
                 control_cluster_listen_addr=None,
                 control_plane_listen_addr=None,
                 host_msg_client_info=None,
                 mpa_msg_client_info=None,
                ):
        """
        :type  type: :class:`str` or ``None``
        :param type: Possible values are: 
            
            *
              :attr:`ControllerClusterRoleConfig.TYPE_MANAGEMENTCLUSTERROLECONFIG`
            *
              :attr:`ControllerClusterRoleConfig.TYPE_CONTROLLERCLUSTERROLECONFIG`
            
             Type of this role configuration
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  control_cluster_listen_addr: :class:`ServiceEndpoint` or ``None``
        :param control_cluster_listen_addr: The IP and port for the control cluster service on this node
        :type  control_plane_listen_addr: :class:`ServiceEndpoint` or ``None``
        :param control_plane_listen_addr: The IP and port for the control plane service on this node
        :type  host_msg_client_info: :class:`MsgClientInfo` or ``None``
        :param host_msg_client_info: 
        :type  mpa_msg_client_info: :class:`MsgClientInfo` or ``None``
        :param mpa_msg_client_info: 
        """
        self.type = type
        self.control_cluster_listen_addr = control_cluster_listen_addr
        self.control_plane_listen_addr = control_plane_listen_addr
        self.host_msg_client_info = host_msg_client_info
        self.mpa_msg_client_info = mpa_msg_client_info
        VapiStruct.__init__(self)


ControllerClusterRoleConfig._set_binding_type(type.StructType(
    'com.vmware.nsx.model.controller_cluster_role_config', {
        'type': type.OptionalType(type.StringType()),
        'control_cluster_listen_addr': type.OptionalType(type.ReferenceType(__name__, 'ServiceEndpoint')),
        'control_plane_listen_addr': type.OptionalType(type.ReferenceType(__name__, 'ServiceEndpoint')),
        'host_msg_client_info': type.OptionalType(type.ReferenceType(__name__, 'MsgClientInfo')),
        'mpa_msg_client_info': type.OptionalType(type.ReferenceType(__name__, 'MsgClientInfo')),
    },
    ControllerClusterRoleConfig,
    False,
    None))



class ControllerClusterStatus(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATUS_NO_CONTROLLERS = "NO_CONTROLLERS"
    """


    """
    STATUS_UNSTABLE = "UNSTABLE"
    """


    """
    STATUS_DEGRADED = "DEGRADED"
    """


    """
    STATUS_STABLE = "STABLE"
    """


    """
    STATUS_UNKNOWN = "UNKNOWN"
    """


    """



    _canonical_to_pep_names = {
                            'status': 'status',
                            }

    def __init__(self,
                 status=None,
                ):
        """
        :type  status: :class:`str` or ``None``
        :param status: Possible values are: 
            
            * :attr:`ControllerClusterStatus.STATUS_NO_CONTROLLERS`
            * :attr:`ControllerClusterStatus.STATUS_UNSTABLE`
            * :attr:`ControllerClusterStatus.STATUS_DEGRADED`
            * :attr:`ControllerClusterStatus.STATUS_STABLE`
            * :attr:`ControllerClusterStatus.STATUS_UNKNOWN`
            
             The current status of the controller cluster
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.status = status
        VapiStruct.__init__(self)


ControllerClusterStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.controller_cluster_status', {
        'status': type.OptionalType(type.StringType()),
    },
    ControllerClusterStatus,
    False,
    None))



class ControllerNodeAggregateInfo(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'display_name': 'display_name',
                            'id': 'id',
                            'node_interface_properties': 'node_interface_properties',
                            'node_interface_statistics': 'node_interface_statistics',
                            'node_status': 'node_status',
                            'node_status_properties': 'node_status_properties',
                            'role_config': 'role_config',
                            }

    def __init__(self,
                 display_name=None,
                 id=None,
                 node_interface_properties=None,
                 node_interface_statistics=None,
                 node_status=None,
                 node_status_properties=None,
                 role_config=None,
                ):
        """
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  node_interface_properties: :class:`list` of :class:`NodeInterfaceProperties` or ``None``
        :param node_interface_properties: Array of Node interface statistic properties
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  node_interface_statistics: :class:`list` of :class:`NodeInterfaceStatisticsProperties` or ``None``
        :param node_interface_statistics: Array of Node network interface statistic properties
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  node_status: :class:`ClusterNodeStatus` or ``None``
        :param node_status: 
        :type  node_status_properties: :class:`list` of :class:`NodeStatusProperties` or ``None``
        :param node_status_properties: Time series of the node's system properties
        :type  role_config: :class:`ControllerClusterRoleConfig` or ``None``
        :param role_config: 
        """
        self.display_name = display_name
        self.id = id
        self.node_interface_properties = node_interface_properties
        self.node_interface_statistics = node_interface_statistics
        self.node_status = node_status
        self.node_status_properties = node_status_properties
        self.role_config = role_config
        VapiStruct.__init__(self)


ControllerNodeAggregateInfo._set_binding_type(type.StructType(
    'com.vmware.nsx.model.controller_node_aggregate_info', {
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'node_interface_properties': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NodeInterfaceProperties'))),
        'node_interface_statistics': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NodeInterfaceStatisticsProperties'))),
        'node_status': type.OptionalType(type.ReferenceType(__name__, 'ClusterNodeStatus')),
        'node_status_properties': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NodeStatusProperties'))),
        'role_config': type.OptionalType(type.ReferenceType(__name__, 'ControllerClusterRoleConfig')),
    },
    ControllerNodeAggregateInfo,
    False,
    None))



class ControllerProfilerProperties(VapiStruct):
    """
    Controller profiler properties

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'enabled': 'enabled',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 enabled=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  enabled: :class:`bool` or ``None``
        :param enabled: True for enabling controller profiler, False for disabling
            controller profiler.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.enabled = enabled
        VapiStruct.__init__(self)


ControllerProfilerProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.controller_profiler_properties', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'enabled': type.OptionalType(type.BooleanType()),
    },
    ControllerProfilerProperties,
    False,
    None))



class CopyFromRemoteFileProperties(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'port': 'port',
                            'server': 'server',
                            'uri': 'uri',
                            'protocol': 'protocol',
                            }

    def __init__(self,
                 port=None,
                 server=None,
                 uri=None,
                 protocol=None,
                ):
        """
        :type  port: :class:`long` or ``None``
        :param port: Server port format: int64
        :type  server: :class:`str` or ``None``
        :param server: Remote server hostname or IP address
        :type  uri: :class:`str` or ``None``
        :param uri: URI of file to copy
        :type  protocol: :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param protocol: Protocol to use to copy file
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`Protocol`. When methods return a value of this class as a
            return value, the attribute will contain all the attributes defined
            in :class:`Protocol`.
        """
        self.port = port
        self.server = server
        self.uri = uri
        self.protocol = protocol
        VapiStruct.__init__(self)


CopyFromRemoteFileProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.copy_from_remote_file_properties', {
        'port': type.OptionalType(type.IntegerType()),
        'server': type.OptionalType(type.StringType()),
        'uri': type.OptionalType(type.StringType()),
        'protocol': type.OptionalType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'Protocol')])),
    },
    CopyFromRemoteFileProperties,
    False,
    None))



class CopyRemoteFileProperties(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'port': 'port',
                            'server': 'server',
                            'uri': 'uri',
                            }

    def __init__(self,
                 port=None,
                 server=None,
                 uri=None,
                ):
        """
        :type  port: :class:`long` or ``None``
        :param port: Server port format: int64
        :type  server: :class:`str` or ``None``
        :param server: Remote server hostname or IP address
        :type  uri: :class:`str` or ``None``
        :param uri: URI of file to copy
        """
        self.port = port
        self.server = server
        self.uri = uri
        VapiStruct.__init__(self)


CopyRemoteFileProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.copy_remote_file_properties', {
        'port': type.OptionalType(type.IntegerType()),
        'server': type.OptionalType(type.StringType()),
        'uri': type.OptionalType(type.StringType()),
    },
    CopyRemoteFileProperties,
    False,
    None))



class CopyToRemoteFileProperties(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'port': 'port',
                            'server': 'server',
                            'uri': 'uri',
                            'protocol': 'protocol',
                            }

    def __init__(self,
                 port=None,
                 server=None,
                 uri=None,
                 protocol=None,
                ):
        """
        :type  port: :class:`long` or ``None``
        :param port: Server port format: int64
        :type  server: :class:`str` or ``None``
        :param server: Remote server hostname or IP address
        :type  uri: :class:`str` or ``None``
        :param uri: URI of file to copy
        :type  protocol: :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param protocol: Only scp and sftp may be used.
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`Protocol`. When methods return a value of this class as a
            return value, the attribute will contain all the attributes defined
            in :class:`Protocol`.
        """
        self.port = port
        self.server = server
        self.uri = uri
        self.protocol = protocol
        VapiStruct.__init__(self)


CopyToRemoteFileProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.copy_to_remote_file_properties', {
        'port': type.OptionalType(type.IntegerType()),
        'server': type.OptionalType(type.StringType()),
        'uri': type.OptionalType(type.StringType()),
        'protocol': type.OptionalType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'Protocol')])),
    },
    CopyToRemoteFileProperties,
    False,
    None))



class CpuCoreConfigForEnhancedNetworkingStackSwitch(VapiStruct):
    """
    Non Uniform Memory Access (NUMA) nodes and Logical cpu cores (Lcores) per
    NUMA node configuration for Enhanced Networking Stack enabled HostSwitch.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'num_lcores': 'num_lcores',
                            'numa_node_index': 'numa_node_index',
                            }

    def __init__(self,
                 num_lcores=None,
                 numa_node_index=None,
                ):
        """
        :type  num_lcores: :class:`long` or ``None``
        :param num_lcores: Number of Logical cpu cores (Lcores) to be placed on a specified
            NUMA node format: int32
        :type  numa_node_index: :class:`long` or ``None``
        :param numa_node_index: Unique index of the Non Uniform Memory Access (NUMA) node format:
            int32
        """
        self.num_lcores = num_lcores
        self.numa_node_index = numa_node_index
        VapiStruct.__init__(self)


CpuCoreConfigForEnhancedNetworkingStackSwitch._set_binding_type(type.StructType(
    'com.vmware.nsx.model.cpu_core_config_for_enhanced_networking_stack_switch', {
        'num_lcores': type.OptionalType(type.IntegerType()),
        'numa_node_index': type.OptionalType(type.IntegerType()),
    },
    CpuCoreConfigForEnhancedNetworkingStackSwitch,
    False,
    None))



class CpuUsage(VapiStruct):
    """
    CPU usage of DPDK and non-DPDK cores

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'avg_cpu_core_usage_dpdk': 'avg_cpu_core_usage_dpdk',
                            'avg_cpu_core_usage_non_dpdk': 'avg_cpu_core_usage_non_dpdk',
                            'highest_cpu_core_usage_dpdk': 'highest_cpu_core_usage_dpdk',
                            'highest_cpu_core_usage_non_dpdk': 'highest_cpu_core_usage_non_dpdk',
                            }

    def __init__(self,
                 avg_cpu_core_usage_dpdk=None,
                 avg_cpu_core_usage_non_dpdk=None,
                 highest_cpu_core_usage_dpdk=None,
                 highest_cpu_core_usage_non_dpdk=None,
                ):
        """
        :type  avg_cpu_core_usage_dpdk: :class:`float` or ``None``
        :param avg_cpu_core_usage_dpdk: Indicates the average usage of all DPDK cores in percentage.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  avg_cpu_core_usage_non_dpdk: :class:`float` or ``None``
        :param avg_cpu_core_usage_non_dpdk: Indicates the average usage of all non-DPDK cores in percentage.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  highest_cpu_core_usage_dpdk: :class:`float` or ``None``
        :param highest_cpu_core_usage_dpdk: Indicates the highest CPU utilization value among DPDK cores in
            percentage.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  highest_cpu_core_usage_non_dpdk: :class:`float` or ``None``
        :param highest_cpu_core_usage_non_dpdk: Indicates the highest cpu utilization value among non_dpdk cores in
            percentage.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.avg_cpu_core_usage_dpdk = avg_cpu_core_usage_dpdk
        self.avg_cpu_core_usage_non_dpdk = avg_cpu_core_usage_non_dpdk
        self.highest_cpu_core_usage_dpdk = highest_cpu_core_usage_dpdk
        self.highest_cpu_core_usage_non_dpdk = highest_cpu_core_usage_non_dpdk
        VapiStruct.__init__(self)


CpuUsage._set_binding_type(type.StructType(
    'com.vmware.nsx.model.cpu_usage', {
        'avg_cpu_core_usage_dpdk': type.OptionalType(type.DoubleType()),
        'avg_cpu_core_usage_non_dpdk': type.OptionalType(type.DoubleType()),
        'highest_cpu_core_usage_dpdk': type.OptionalType(type.DoubleType()),
        'highest_cpu_core_usage_non_dpdk': type.OptionalType(type.DoubleType()),
    },
    CpuUsage,
    False,
    None))



class CreateRemoteDirectoryProperties(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'port': 'port',
                            'server': 'server',
                            'uri': 'uri',
                            'protocol': 'protocol',
                            }

    def __init__(self,
                 port=None,
                 server=None,
                 uri=None,
                 protocol=None,
                ):
        """
        :type  port: :class:`long` or ``None``
        :param port: Server port format: int64
        :type  server: :class:`str` or ``None``
        :param server: Remote server hostname or IP address
        :type  uri: :class:`str` or ``None``
        :param uri: URI of file to copy
        :type  protocol: :class:`SftpProtocol` or ``None``
        :param protocol: Protocol to use to copy file
        """
        self.port = port
        self.server = server
        self.uri = uri
        self.protocol = protocol
        VapiStruct.__init__(self)


CreateRemoteDirectoryProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.create_remote_directory_properties', {
        'port': type.OptionalType(type.IntegerType()),
        'server': type.OptionalType(type.StringType()),
        'uri': type.OptionalType(type.StringType()),
        'protocol': type.OptionalType(type.ReferenceType(__name__, 'SftpProtocol')),
    },
    CreateRemoteDirectoryProperties,
    False,
    None))



class Crl(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'details': 'details',
                            'pem_encoded': 'pem_encoded',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 details=None,
                 pem_encoded=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  details: :class:`X509Crl` or ``None``
        :param details: Details of the X509Crl object.
        :type  pem_encoded: :class:`str` or ``None``
        :param pem_encoded: PEM encoded CRL data.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.details = details
        self.pem_encoded = pem_encoded
        VapiStruct.__init__(self)


Crl._set_binding_type(type.StructType(
    'com.vmware.nsx.model.crl', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'details': type.OptionalType(type.ReferenceType(__name__, 'X509Crl')),
        'pem_encoded': type.OptionalType(type.StringType()),
    },
    Crl,
    False,
    None))



class CrlDistributionPoint(VapiStruct):
    """
    Reference to a CRL Distribution Point where to fetch a CRL

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'cdp_uri': 'cdp_uri',
                            'issuer': 'issuer',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 cdp_uri=None,
                 issuer=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  cdp_uri: :class:`str` or ``None``
        :param cdp_uri: CRL Distribution Point URI where to fetch the CRL.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  issuer: :class:`str` or ``None``
        :param issuer: Issuer of the CRL, referring to the CA.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.cdp_uri = cdp_uri
        self.issuer = issuer
        VapiStruct.__init__(self)


CrlDistributionPoint._set_binding_type(type.StructType(
    'com.vmware.nsx.model.crl_distribution_point', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'cdp_uri': type.OptionalType(type.StringType()),
        'issuer': type.OptionalType(type.StringType()),
    },
    CrlDistributionPoint,
    False,
    None))



class CrlDistributionPointList(VapiStruct):
    """
    CrlDistributionPoint query result

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`CrlDistributionPoint` or ``None``
        :param results: CrlDistributionPoint list.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


CrlDistributionPointList._set_binding_type(type.StructType(
    'com.vmware.nsx.model.crl_distribution_point_list', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'CrlDistributionPoint'))),
    },
    CrlDistributionPointList,
    False,
    None))



class CrlDistributionPointStatus(VapiStruct):
    """
    Reference to a CRL Distribution Point where to fetch a CRL

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATUS_NOT_READY = "NOT_READY"
    """


    """
    STATUS_FETCHING = "FETCHING"
    """


    """
    STATUS_READY = "READY"
    """


    """
    STATUS_ERROR = "ERROR"
    """


    """



    _canonical_to_pep_names = {
                            'error_message': 'error_message',
                            'status': 'status',
                            }

    def __init__(self,
                 error_message=None,
                 status=None,
                ):
        """
        :type  error_message: :class:`str` or ``None``
        :param error_message: Error message when fetching the CRL failed.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  status: :class:`str` or ``None``
        :param status: Possible values are: 
            
            * :attr:`CrlDistributionPointStatus.STATUS_NOT_READY`
            * :attr:`CrlDistributionPointStatus.STATUS_FETCHING`
            * :attr:`CrlDistributionPointStatus.STATUS_READY`
            * :attr:`CrlDistributionPointStatus.STATUS_ERROR`
            
             Status of the fetched CRL for this CrlDistributionPoint
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.error_message = error_message
        self.status = status
        VapiStruct.__init__(self)


CrlDistributionPointStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.crl_distribution_point_status', {
        'error_message': type.OptionalType(type.StringType()),
        'status': type.OptionalType(type.StringType()),
    },
    CrlDistributionPointStatus,
    False,
    None))



class CrlList(VapiStruct):
    """
    Crl queries result

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`Crl` or ``None``
        :param results: CRL list.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


CrlList._set_binding_type(type.StructType(
    'com.vmware.nsx.model.crl_list', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Crl'))),
    },
    CrlList,
    False,
    None))



class CrlObjectData(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'pem_encoded': 'pem_encoded',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 pem_encoded=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  pem_encoded: :class:`str` or ``None``
        :param pem_encoded: PEM encoded CRL data.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.pem_encoded = pem_encoded
        VapiStruct.__init__(self)


CrlObjectData._set_binding_type(type.StructType(
    'com.vmware.nsx.model.crl_object_data', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'pem_encoded': type.OptionalType(type.StringType()),
    },
    CrlObjectData,
    False,
    None))



class CrlPemRequestType(VapiStruct):
    """
    Request Type to get a CRL's PEM file.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'cdp_uri': 'cdp_uri',
                            }

    def __init__(self,
                 cdp_uri=None,
                ):
        """
        :type  cdp_uri: :class:`str` or ``None``
        :param cdp_uri: CRL Distribution Point URI where to fetch the CRL.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.cdp_uri = cdp_uri
        VapiStruct.__init__(self)


CrlPemRequestType._set_binding_type(type.StructType(
    'com.vmware.nsx.model.crl_pem_request_type', {
        'cdp_uri': type.OptionalType(type.StringType()),
    },
    CrlPemRequestType,
    False,
    None))



class CryptoAlgorithm(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'key_size': 'key_size',
                            'name': 'name',
                            }

    def __init__(self,
                 key_size=None,
                 name=None,
                ):
        """
        :type  key_size: :class:`list` of :class:`long` or ``None``
        :param key_size: Supported key sizes for the algorithm. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  name: :class:`str` or ``None``
        :param name: Crypto algorithm name.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.key_size = key_size
        self.name = name
        VapiStruct.__init__(self)


CryptoAlgorithm._set_binding_type(type.StructType(
    'com.vmware.nsx.model.crypto_algorithm', {
        'key_size': type.OptionalType(type.ListType(type.IntegerType())),
        'name': type.OptionalType(type.StringType()),
    },
    CryptoAlgorithm,
    False,
    None))



class Csr(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    ALGORITHM_RSA = "RSA"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'algorithm': 'algorithm',
                            'key_size': 'key_size',
                            'pem_encoded': 'pem_encoded',
                            'subject': 'subject',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 algorithm=None,
                 key_size=None,
                 pem_encoded=None,
                 subject=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  algorithm: :class:`str` or ``None``
        :param algorithm: Possible values are: 
            
            * :attr:`Csr.ALGORITHM_RSA`
            
            Cryptographic algorithm(asymmetric ) used by the public key for
            data encryption.
        :type  key_size: :class:`long` or ``None``
        :param key_size: Size measured in bits of the public key used in a cryptographic
            algorithm. format: int64
        :type  pem_encoded: :class:`str` or ``None``
        :param pem_encoded: PEM encoded certificate data.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  subject: :class:`Principal` or ``None``
        :param subject: The certificate owner's information. (CN, O, OU, C, ST, L)
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.algorithm = algorithm
        self.key_size = key_size
        self.pem_encoded = pem_encoded
        self.subject = subject
        VapiStruct.__init__(self)


Csr._set_binding_type(type.StructType(
    'com.vmware.nsx.model.csr', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'algorithm': type.OptionalType(type.StringType()),
        'key_size': type.OptionalType(type.IntegerType()),
        'pem_encoded': type.OptionalType(type.StringType()),
        'subject': type.OptionalType(type.ReferenceType(__name__, 'Principal')),
    },
    Csr,
    False,
    None))



class CsrList(VapiStruct):
    """
    Csr queries result

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`Csr` or ``None``
        :param results: CSR list.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


CsrList._set_binding_type(type.StructType(
    'com.vmware.nsx.model.csr_list', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Csr'))),
    },
    CsrList,
    False,
    None))



class CsvListResult(VapiStruct):
    """
    Base type for CSV result.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'file_name': 'file_name',
                            }

    def __init__(self,
                 file_name=None,
                ):
        """
        :type  file_name: :class:`str` or ``None``
        :param file_name: File name set by HTTP server if API returns CSV result as a file.
        """
        self.file_name = file_name
        VapiStruct.__init__(self)


CsvListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.csv_list_result', {
        'file_name': type.OptionalType(type.StringType()),
    },
    CsvListResult,
    False,
    None))



class CsvRecord(VapiStruct):
    """
    Base type for CSV records.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """




    def __init__(self,
                ):
        """
        """
        VapiStruct.__init__(self)


CsvRecord._set_binding_type(type.StructType(
    'com.vmware.nsx.model.csv_record', {
    },
    CsvRecord,
    False,
    None))



class CurrentBackupOperationStatus(VapiStruct):
    """
    Current backup operation status

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    CURRENT_STEP_CLUSTER_BACKUP = "BACKUP_CREATING_CLUSTER_BACKUP"
    """


    """
    CURRENT_STEP_NODE_BACKUP = "BACKUP_CREATING_NODE_BACKUP"
    """


    """
    OPERATION_TYPE_NONE = "NONE"
    """


    """
    OPERATION_TYPE_BACKUP = "BACKUP"
    """


    """



    _canonical_to_pep_names = {
                            'backup_id': 'backup_id',
                            'current_step': 'current_step',
                            'current_step_message': 'current_step_message',
                            'end_time': 'end_time',
                            'operation_type': 'operation_type',
                            'start_time': 'start_time',
                            }

    def __init__(self,
                 backup_id=None,
                 current_step=None,
                 current_step_message=None,
                 end_time=None,
                 operation_type=None,
                 start_time=None,
                ):
        """
        :type  backup_id: :class:`str` or ``None``
        :param backup_id: Unique identifier of current backup
        :type  current_step: :class:`str` or ``None``
        :param current_step: Possible values are: 
            
            * :attr:`CurrentBackupOperationStatus.CURRENT_STEP_CLUSTER_BACKUP`
            * :attr:`CurrentBackupOperationStatus.CURRENT_STEP_NODE_BACKUP`
            
             Current step of operation
        :type  current_step_message: :class:`str` or ``None``
        :param current_step_message: Additional human-readable status information about current step
        :type  end_time: :class:`long` or ``None``
        :param end_time: Time when operation is expected to end format: int64
        :type  operation_type: :class:`str` or ``None``
        :param operation_type: Possible values are: 
            
            * :attr:`CurrentBackupOperationStatus.OPERATION_TYPE_NONE`
            * :attr:`CurrentBackupOperationStatus.OPERATION_TYPE_BACKUP`
            
            Type of operation that is in progress. Returns none if no operation
            is in progress, in which case none of the other fields will be set.
        :type  start_time: :class:`long` or ``None``
        :param start_time: Time when operation was started format: int64
        """
        self.backup_id = backup_id
        self.current_step = current_step
        self.current_step_message = current_step_message
        self.end_time = end_time
        self.operation_type = operation_type
        self.start_time = start_time
        VapiStruct.__init__(self)


CurrentBackupOperationStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.current_backup_operation_status', {
        'backup_id': type.OptionalType(type.StringType()),
        'current_step': type.OptionalType(type.StringType()),
        'current_step_message': type.OptionalType(type.StringType()),
        'end_time': type.OptionalType(type.IntegerType()),
        'operation_type': type.OptionalType(type.StringType()),
        'start_time': type.OptionalType(type.IntegerType()),
    },
    CurrentBackupOperationStatus,
    False,
    None))



class CurrentRealizationStateBarrier(VapiStruct):
    """
    The current global barrier number of the realized state

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'current_barrier_number': 'current_barrier_number',
                            }

    def __init__(self,
                 current_barrier_number=None,
                ):
        """
        :type  current_barrier_number: :class:`long` or ``None``
        :param current_barrier_number: Gives the current global barrier number for NSX format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.current_barrier_number = current_barrier_number
        VapiStruct.__init__(self)


CurrentRealizationStateBarrier._set_binding_type(type.StructType(
    'com.vmware.nsx.model.current_realization_state_barrier', {
        'current_barrier_number': type.OptionalType(type.IntegerType()),
    },
    CurrentRealizationStateBarrier,
    False,
    None))



class CustomWidgetConfiguration(VapiStruct):
    """
    Represents configuration for custom widget. For this widget the data source
    is not applicable. It defines ui identifer to identify UI component and
    render it on dashboard view. This configuration can only be used for system
    owned widgets.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "CustomWidgetConfiguration"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'ui_component_identifier': 'ui_component_identifier',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'datasources': 'datasources',
                            'default_filter_value': 'default_filter_value',
                            'drilldown_id': 'drilldown_id',
                            'filter': 'filter',
                            'filter_value_required': 'filter_value_required',
                            'footer': 'footer',
                            'icons': 'icons',
                            'is_drilldown': 'is_drilldown',
                            'legend': 'legend',
                            'shared': 'shared',
                            'span': 'span',
                            'weight': 'weight',
                            }

    def __init__(self,
                 ui_component_identifier=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='CustomWidgetConfiguration',
                 tags=None,
                 datasources=None,
                 default_filter_value=None,
                 drilldown_id=None,
                 filter=None,
                 filter_value_required=None,
                 footer=None,
                 icons=None,
                 is_drilldown=None,
                 legend=None,
                 shared=None,
                 span=None,
                 weight=None,
                ):
        """
        :type  ui_component_identifier: :class:`str` or ``None``
        :param ui_component_identifier: User defined component selector to be rendered inside
            view/container.
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Title of the widget. If display_name is omitted, the widget will be
            shown without a title.
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_LABELVALUECONFIGURATION`
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_DONUTCONFIGURATION`
            *
              :attr:`WidgetConfiguration.RESOURCE_TYPE_MULTIWIDGETCONFIGURATION`
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_CONTAINERCONFIGURATION`
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_STATSCONFIGURATION`
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_GRIDCONFIGURATION`
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_GRAPHCONFIGURATION`
            *
              :attr:`WidgetConfiguration.RESOURCE_TYPE_CUSTOMWIDGETCONFIGURATION`
            *
              :attr:`WidgetConfiguration.RESOURCE_TYPE_DROPDOWNFILTERWIDGETCONFIGURATION`
            
            Supported visualization types are LabelValueConfiguration,
            DonutConfiguration, GridConfiguration, StatsConfiguration,
            MultiWidgetConfiguration, GraphConfiguration,
            ContainerConfiguration, CustomWidgetConfiguration and
            DropdownFilterWidgetConfiguration.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  datasources: :class:`list` of :class:`Datasource` or ``None``
        :param datasources: The 'datasources' represent the sources from which data will be
            fetched. Currently, only NSX-API is supported as a 'default'
            datasource. An example of specifying 'default' datasource along
            with the urls to fetch data from is given at 'example_request'
            section of 'CreateWidgetConfiguration' API.
        :type  default_filter_value: :class:`list` of :class:`DefaultFilterValue` or ``None``
        :param default_filter_value: Default filter values to be passed to datasources. This will be
            used when the report is requested without filter values.
        :type  drilldown_id: :class:`str` or ``None``
        :param drilldown_id: Id of drilldown widget, if any. Id should be a valid id of an
            existing widget. A widget is considered as drilldown widget when it
            is associated with any other widget and provides more detailed
            information about any data item from the parent widget.
        :type  filter: :class:`str` or ``None``
        :param filter: Id of filter widget for subscription, if any. Id should be a valid
            id of an existing filter widget. Filter widget should be from the
            same view. Datasource URLs should have placeholder values equal to
            filter alias to accept the filter value on filter change.
        :type  filter_value_required: :class:`bool` or ``None``
        :param filter_value_required: Flag to indicate that widget will continue to work without filter
            value. If this flag is set to false then default_filter_value is
            manadatory.
        :type  footer: :class:`Footer` or ``None``
        :param footer: 
        :type  icons: :class:`list` of :class:`Icon` or ``None``
        :param icons: Icons to be applied at dashboard for widgets and UI elements.
        :type  is_drilldown: :class:`bool` or ``None``
        :param is_drilldown: Set to true if this widget should be used as a drilldown.
        :type  legend: :class:`Legend` or ``None``
        :param legend: Legend to be displayed. If legend is not needed, do not include it.
        :type  shared: :class:`bool` or ``None``
        :param shared: Please use the property 'shared' of View instead of this. The
            widgets of a shared view are visible to other users.
        :type  span: :class:`long` or ``None``
        :param span: Represents the horizontal span of the widget / container. format:
            int32
        :type  weight: :class:`long` or ``None``
        :param weight: Specify relavite weight in WidgetItem for placement in a view.
            Please see WidgetItem for details. format: int32
        """
        self.ui_component_identifier = ui_component_identifier
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        self.datasources = datasources
        self.default_filter_value = default_filter_value
        self.drilldown_id = drilldown_id
        self.filter = filter
        self.filter_value_required = filter_value_required
        self.footer = footer
        self.icons = icons
        self.is_drilldown = is_drilldown
        self.legend = legend
        self.shared = shared
        self.span = span
        self.weight = weight
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

CustomWidgetConfiguration._set_binding_type(type.StructType(
    'com.vmware.nsx.model.custom_widget_configuration', {
        'ui_component_identifier': type.OptionalType(type.StringType()),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'datasources': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Datasource'))),
        'default_filter_value': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'DefaultFilterValue'))),
        'drilldown_id': type.OptionalType(type.StringType()),
        'filter': type.OptionalType(type.StringType()),
        'filter_value_required': type.OptionalType(type.BooleanType()),
        'footer': type.OptionalType(type.ReferenceType(__name__, 'Footer')),
        'icons': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Icon'))),
        'is_drilldown': type.OptionalType(type.BooleanType()),
        'legend': type.OptionalType(type.ReferenceType(__name__, 'Legend')),
        'shared': type.OptionalType(type.BooleanType()),
        'span': type.OptionalType(type.IntegerType()),
        'weight': type.OptionalType(type.IntegerType()),
    },
    CustomWidgetConfiguration,
    False,
    None))



class DADProfile(VapiStruct):
    """
    Duplicate address detection profile.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    DAD_MODE_LOOSE = "LOOSE"
    """


    """
    DAD_MODE_STRICT = "STRICT"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'dad_mode': 'dad_mode',
                            'ns_retries': 'ns_retries',
                            'wait_time': 'wait_time',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 dad_mode=None,
                 ns_retries=None,
                 wait_time=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  dad_mode: :class:`str` or ``None``
        :param dad_mode: Possible values are: 
            
            * :attr:`DADProfile.DAD_MODE_LOOSE`
            * :attr:`DADProfile.DAD_MODE_STRICT`
            
             DAD Mode
        :type  ns_retries: :class:`long` or ``None``
        :param ns_retries: Number of Neighbor solicitation packets generated before completing
            the Duplicate address detection process. format: int64
        :type  wait_time: :class:`long` or ``None``
        :param wait_time: The time duration in seconds, to wait for Neighbor advertisement
            after sending the Neighbor solicitation message. format: int64
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.dad_mode = dad_mode
        self.ns_retries = ns_retries
        self.wait_time = wait_time
        VapiStruct.__init__(self)


DADProfile._set_binding_type(type.StructType(
    'com.vmware.nsx.model.DAD_profile', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'dad_mode': type.OptionalType(type.StringType()),
        'ns_retries': type.OptionalType(type.IntegerType()),
        'wait_time': type.OptionalType(type.IntegerType()),
    },
    DADProfile,
    False,
    None))



class DADProfileListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`DADProfile` or ``None``
        :param results: Paginated list of DADProfile
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


DADProfileListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.DAD_profile_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'DADProfile'))),
    },
    DADProfileListResult,
    False,
    None))



class DSExcludeList(VapiStruct):
    """
    List of entities excluded for enforcing a service or a feature.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'member_count': 'member_count',
                            'members': 'members',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 member_count=None,
                 members=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  member_count: :class:`long` or ``None``
        :param member_count: Total number of members present in Exclude List. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  members: :class:`list` of :class:`ResourceReference` or ``None``
        :param members: List of members in Exclusion List
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.member_count = member_count
        self.members = members
        VapiStruct.__init__(self)


DSExcludeList._set_binding_type(type.StructType(
    'com.vmware.nsx.model.DS_exclude_list', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'member_count': type.OptionalType(type.IntegerType()),
        'members': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceReference'))),
    },
    DSExcludeList,
    False,
    None))



class DSInsertParameters(VapiStruct):
    """
    Parameters to tell where rule/section need to be added. All the params take
    rule/section Id.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    OPERATION_TOP = "insert_top"
    """


    """
    OPERATION_BOTTOM = "insert_bottom"
    """


    """
    OPERATION_AFTER = "insert_after"
    """


    """
    OPERATION_BEFORE = "insert_before"
    """


    """



    _canonical_to_pep_names = {
                            'id': 'id',
                            'operation': 'operation',
                            }

    def __init__(self,
                 id=None,
                 operation=None,
                ):
        """
        :type  id: :class:`str` or ``None``
        :param id: Identifier of the anchor rule or section. This is a required field
            in case operation like 'insert_before' and 'insert_after'.
        :type  operation: :class:`str` or ``None``
        :param operation: Possible values are: 
            
            * :attr:`DSInsertParameters.OPERATION_TOP`
            * :attr:`DSInsertParameters.OPERATION_BOTTOM`
            * :attr:`DSInsertParameters.OPERATION_AFTER`
            * :attr:`DSInsertParameters.OPERATION_BEFORE`
            
             Operation
        """
        self.id = id
        self.operation = operation
        VapiStruct.__init__(self)


DSInsertParameters._set_binding_type(type.StructType(
    'com.vmware.nsx.model.DS_insert_parameters', {
        'id': type.OptionalType(type.StringType()),
        'operation': type.OptionalType(type.StringType()),
    },
    DSInsertParameters,
    False,
    None))



class DSRule(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    ACTION_ALLOW = "ALLOW"
    """


    """
    ACTION_DROP = "DROP"
    """


    """
    ACTION_REJECT = "REJECT"
    """


    """
    ACTION_REDIRECT = "REDIRECT"
    """


    """
    ACTION_DO_NOT_REDIRECT = "DO_NOT_REDIRECT"
    """


    """
    ACTION_DETECT = "DETECT"
    """


    """
    DIRECTION_IN = "IN"
    """


    """
    DIRECTION_OUT = "OUT"
    """


    """
    DIRECTION_IN_OUT = "IN_OUT"
    """


    """
    IP_PROTOCOL_IPV4 = "IPV4"
    """


    """
    IP_PROTOCOL_IPV6 = "IPV6"
    """


    """
    IP_PROTOCOL_IPV4_IPV6 = "IPV4_IPV6"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_owner': 'owner',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'action': 'action',
                            'applied_tos': 'applied_tos',
                            'destinations': 'destinations',
                            'destinations_excluded': 'destinations_excluded',
                            'direction': 'direction',
                            'disabled': 'disabled',
                            'ip_protocol': 'ip_protocol',
                            'is_default': 'is_default',
                            'logged': 'logged',
                            'notes': 'notes',
                            'priority': 'priority',
                            'rule_tag': 'rule_tag',
                            'sources': 'sources',
                            'sources_excluded': 'sources_excluded',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 owner=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 action=None,
                 applied_tos=None,
                 destinations=None,
                 destinations_excluded=None,
                 direction=None,
                 disabled=None,
                 ip_protocol=None,
                 is_default=None,
                 logged=None,
                 notes=None,
                 priority=None,
                 rule_tag=None,
                 sources=None,
                 sources_excluded=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  owner: :class:`OwnerResourceLink` or ``None``
        :param owner: Owner of this resource
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Identifier of the resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  action: :class:`str` or ``None``
        :param action: Possible values are: 
            
            * :attr:`DSRule.ACTION_ALLOW`
            * :attr:`DSRule.ACTION_DROP`
            * :attr:`DSRule.ACTION_REJECT`
            * :attr:`DSRule.ACTION_REDIRECT`
            * :attr:`DSRule.ACTION_DO_NOT_REDIRECT`
            * :attr:`DSRule.ACTION_DETECT`
            
            Action enforced on the packets which matches the distributed
            service rule. Currently DS Layer supports below actions. ALLOW -
            Forward any packet when a rule with this action gets a match (Used
            by Firewall). DROP - Drop any packet when a rule with this action
            gets a match. Packets won't go further(Used by Firewall). REJECT -
            Terminate TCP connection by sending TCP reset for a packet when a
            rule with this action gets a match (Used by Firewall). REDIRECT -
            Redirect any packet to a partner appliance when a rule with this
            action gets a match (Used by Service Insertion). DO_NOT_REDIRECT -
            Do not redirect any packet to a partner appliance when a rule with
            this action gets a match (Used by Service Insertion). DETECT -
            Detect IDS Signatures.
        :type  applied_tos: :class:`list` of :class:`ResourceReference` or ``None``
        :param applied_tos: List of object where rule will be enforced. The section level field
            overrides this one. Null will be treated as any.
        :type  destinations: :class:`list` of :class:`ResourceReference` or ``None``
        :param destinations: List of the destinations. Null will be treated as any.
        :type  destinations_excluded: :class:`bool` or ``None``
        :param destinations_excluded: Negation of the destination.
        :type  direction: :class:`str` or ``None``
        :param direction: Possible values are: 
            
            * :attr:`DSRule.DIRECTION_IN`
            * :attr:`DSRule.DIRECTION_OUT`
            * :attr:`DSRule.DIRECTION_IN_OUT`
            
            Rule direction in case of stateless distributed service rules. This
            will only considered if section level parameter is set to
            stateless. Default to IN_OUT if not specified.
        :type  disabled: :class:`bool` or ``None``
        :param disabled: Flag to disable rule. Disabled will only be persisted but never
            provisioned/realized.
        :type  ip_protocol: :class:`str` or ``None``
        :param ip_protocol: Possible values are: 
            
            * :attr:`DSRule.IP_PROTOCOL_IPV4`
            * :attr:`DSRule.IP_PROTOCOL_IPV6`
            * :attr:`DSRule.IP_PROTOCOL_IPV4_IPV6`
            
             Type of IP packet that should be matched while enforcing the rule.
        :type  is_default: :class:`bool` or ``None``
        :param is_default: Flag to indicate whether rule is default.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  logged: :class:`bool` or ``None``
        :param logged: Flag to enable packet logging. Default is disabled.
        :type  notes: :class:`str` or ``None``
        :param notes: User notes specific to the rule.
        :type  priority: :class:`long` or ``None``
        :param priority: Priority of the rule. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  rule_tag: :class:`str` or ``None``
        :param rule_tag: User level field which will be printed in CLI and packet logs.
        :type  sources: :class:`list` of :class:`ResourceReference` or ``None``
        :param sources: List of sources. Null will be treated as any.
        :type  sources_excluded: :class:`bool` or ``None``
        :param sources_excluded: Negation of the source.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.owner = owner
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.action = action
        self.applied_tos = applied_tos
        self.destinations = destinations
        self.destinations_excluded = destinations_excluded
        self.direction = direction
        self.disabled = disabled
        self.ip_protocol = ip_protocol
        self.is_default = is_default
        self.logged = logged
        self.notes = notes
        self.priority = priority
        self.rule_tag = rule_tag
        self.sources = sources
        self.sources_excluded = sources_excluded
        VapiStruct.__init__(self)


DSRule._set_binding_type(type.StructType(
    'com.vmware.nsx.model.DS_rule', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_owner': type.OptionalType(type.ReferenceType(__name__, 'OwnerResourceLink')),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'action': type.OptionalType(type.StringType()),
        'applied_tos': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceReference'))),
        'destinations': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceReference'))),
        'destinations_excluded': type.OptionalType(type.BooleanType()),
        'direction': type.OptionalType(type.StringType()),
        'disabled': type.OptionalType(type.BooleanType()),
        'ip_protocol': type.OptionalType(type.StringType()),
        'is_default': type.OptionalType(type.BooleanType()),
        'logged': type.OptionalType(type.BooleanType()),
        'notes': type.OptionalType(type.StringType()),
        'priority': type.OptionalType(type.IntegerType()),
        'rule_tag': type.OptionalType(type.StringType()),
        'sources': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceReference'))),
        'sources_excluded': type.OptionalType(type.BooleanType()),
    },
    DSRule,
    False,
    None))



class DSRuleState(VapiStruct):
    """
    Rule Realization State

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATE_PENDING = "pending"
    """


    """
    STATE_IN_PROGRESS = "in_progress"
    """


    """
    STATE_SUCCESS = "success"
    """


    """
    STATE_FAILED = "failed"
    """


    """
    STATE_PARTIAL_SUCCESS = "partial_success"
    """


    """
    STATE_ORPHANED = "orphaned"
    """


    """
    STATE_UNKNOWN = "unknown"
    """


    """
    STATE_ERROR = "error"
    """


    """
    STATE_IN_SYNC = "in_sync"
    """


    """
    STATE_NOT_AVAILABLE = "NOT_AVAILABLE"
    """


    """
    STATE_VM_DEPLOYMENT_QUEUED = "VM_DEPLOYMENT_QUEUED"
    """


    """
    STATE_VM_DEPLOYMENT_IN_PROGRESS = "VM_DEPLOYMENT_IN_PROGRESS"
    """


    """
    STATE_VM_DEPLOYMENT_FAILED = "VM_DEPLOYMENT_FAILED"
    """


    """
    STATE_VM_POWER_ON_IN_PROGRESS = "VM_POWER_ON_IN_PROGRESS"
    """


    """
    STATE_VM_POWER_ON_FAILED = "VM_POWER_ON_FAILED"
    """


    """
    STATE_REGISTRATION_PENDING = "REGISTRATION_PENDING"
    """


    """
    STATE_NODE_NOT_READY = "NODE_NOT_READY"
    """


    """
    STATE_NODE_READY = "NODE_READY"
    """


    """
    STATE_VM_POWER_OFF_IN_PROGRESS = "VM_POWER_OFF_IN_PROGRESS"
    """


    """
    STATE_VM_POWER_OFF_FAILED = "VM_POWER_OFF_FAILED"
    """


    """
    STATE_VM_UNDEPLOY_IN_PROGRESS = "VM_UNDEPLOY_IN_PROGRESS"
    """


    """
    STATE_VM_UNDEPLOY_FAILED = "VM_UNDEPLOY_FAILED"
    """


    """
    STATE_VM_UNDEPLOY_SUCCESSFUL = "VM_UNDEPLOY_SUCCESSFUL"
    """


    """
    STATE_EDGE_CONFIG_ERROR = "EDGE_CONFIG_ERROR"
    """


    """
    STATE_VM_DEPLOYMENT_RESTARTED = "VM_DEPLOYMENT_RESTARTED"
    """


    """
    STATE_REGISTRATION_FAILED = "REGISTRATION_FAILED"
    """


    """
    STATE_TRANSPORT_NODE_SYNC_PENDING = "TRANSPORT_NODE_SYNC_PENDING"
    """


    """
    STATE_TRANSPORT_NODE_CONFIGURATION_MISSING = "TRANSPORT_NODE_CONFIGURATION_MISSING"
    """


    """
    STATE_EDGE_HARDWARE_NOT_SUPPORTED = "EDGE_HARDWARE_NOT_SUPPORTED"
    """


    """
    STATE_MULTIPLE_OVERLAY_TZS_NOT_SUPPORTED = "MULTIPLE_OVERLAY_TZS_NOT_SUPPORTED"
    """


    """
    STATE_TN_OVERLAY_TZ_IN_USE_BY_EDGE_CLUSTER = "TN_OVERLAY_TZ_IN_USE_BY_EDGE_CLUSTER"
    """


    """
    STATE_TZ_ENDPOINTS_NOT_SPECIFIED = "TZ_ENDPOINTS_NOT_SPECIFIED"
    """


    """
    STATE_NO_PNIC_PREPARED_IN_EDGE = "NO_PNIC_PREPARED_IN_EDGE"
    """


    """
    STATE_APPLIANCE_INTERNAL_ERROR = "APPLIANCE_INTERNAL_ERROR"
    """


    """
    STATE_VTEP_DHCP_NOT_SUPPORTED = "VTEP_DHCP_NOT_SUPPORTED"
    """


    """
    STATE_UNSUPPORTED_HOST_SWITCH_PROFILE = "UNSUPPORTED_HOST_SWITCH_PROFILE"
    """


    """
    STATE_UPLINK_HOST_SWITCH_PROFILE_NOT_SPECIFIED = "UPLINK_HOST_SWITCH_PROFILE_NOT_SPECIFIED"
    """


    """
    STATE_HOSTSWITCH_PROFILE_NOT_FOUND = "HOSTSWITCH_PROFILE_NOT_FOUND"
    """


    """
    STATE_LLDP_SEND_ENABLED_NOT_SUPPORTED = "LLDP_SEND_ENABLED_NOT_SUPPORTED"
    """


    """
    STATE_UNSUPPORTED_NAMED_TEAMING_POLICY = "UNSUPPORTED_NAMED_TEAMING_POLICY"
    """


    """
    STATE_LBSRCID_NOT_SUPPORTED_FOR_EDGE_VM = "LBSRCID_NOT_SUPPORTED_FOR_EDGE_VM"
    """


    """
    STATE_LACP_NOT_SUPPORTED_FOR_EDGE_VM = "LACP_NOT_SUPPORTED_FOR_EDGE_VM"
    """


    """
    STATE_STANDBY_UPLINKS_NOT_SUPPORTED_FOR_EDGE_VM = "STANDBY_UPLINKS_NOT_SUPPORTED_FOR_EDGE_VM"
    """


    """
    STATE_MULTIPLE_ACTIVE_UPLINKS_NOT_SUPPORTED_FOR_EDGE = "MULTIPLE_ACTIVE_UPLINKS_NOT_SUPPORTED_FOR_EDGE"
    """


    """
    STATE_UNSUPPORTED_LACP_LB_ALGO_FOR_NODE = "UNSUPPORTED_LACP_LB_ALGO_FOR_NODE"
    """


    """
    STATE_EDGE_NODE_VERSION_NOT_SUPPORTED = "EDGE_NODE_VERSION_NOT_SUPPORTED"
    """


    """
    STATE_NO_PNIC_SPECIFIED_IN_TN = "NO_PNIC_SPECIFIED_IN_TN"
    """


    """
    STATE_INVALID_PNIC_DEVICE_NAME = "INVALID_PNIC_DEVICE_NAME"
    """


    """
    STATE_TRANSPORT_NODE_READY = "TRANSPORT_NODE_READY"
    """


    """
    STATE_VM_NETWORK_EDIT_PENDING = "VM_NETWORK_EDIT_PENDING"
    """


    """
    STATE_UNSUPPORTED_DEFAULT_TEAMING_POLICY = "UNSUPPORTED_DEFAULT_TEAMING_POLICY"
    """


    """
    STATE_MPA_DISCONNECTED = "MPA_DISCONNECTED"
    """


    """
    STATE_VM_RENAME_PENDING = "VM_RENAME_PENDING"
    """


    """
    STATE_VM_CONFIG_EDIT_PENDING = "VM_CONFIG_EDIT_PENDING"
    """


    """
    STATE_VM_NETWORK_EDIT_FAILED = "VM_NETWORK_EDIT_FAILED"
    """


    """
    STATE_VM_RENAME_FAILED = "VM_RENAME_FAILED"
    """


    """
    STATE_VM_CONFIG_EDIT_FAILED = "VM_CONFIG_EDIT_FAILED"
    """


    """
    STATE_VM_CONFIG_DISCREPANCY = "VM_CONFIG_DISCREPANCY"
    """


    """
    STATE_VM_NODE_REFRESH_FAILED = "VM_NODE_REFRESH_FAILED"
    """


    """
    STATE_VM_PLACEMENT_REFRESH_FAILED = "VM_PLACEMENT_REFRESH_FAILED"
    """


    """
    STATE_REGISTRATION_TIMEDOUT = "REGISTRATION_TIMEDOUT"
    """


    """



    _canonical_to_pep_names = {
                            'details': 'details',
                            'failure_code': 'failure_code',
                            'failure_message': 'failure_message',
                            'state': 'state',
                            'revision_desired': 'revision_desired',
                            }

    def __init__(self,
                 details=None,
                 failure_code=None,
                 failure_message=None,
                 state=None,
                 revision_desired=None,
                ):
        """
        :type  details: :class:`list` of :class:`ConfigurationStateElement` or ``None``
        :param details: Array of configuration state of various sub systems
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  failure_code: :class:`long` or ``None``
        :param failure_code: Error code format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  failure_message: :class:`str` or ``None``
        :param failure_message: Error message in case of failure
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  state: :class:`str` or ``None``
        :param state: Possible values are: 
            
            * :attr:`DSRuleState.STATE_PENDING`
            * :attr:`DSRuleState.STATE_IN_PROGRESS`
            * :attr:`DSRuleState.STATE_SUCCESS`
            * :attr:`DSRuleState.STATE_FAILED`
            * :attr:`DSRuleState.STATE_PARTIAL_SUCCESS`
            * :attr:`DSRuleState.STATE_ORPHANED`
            * :attr:`DSRuleState.STATE_UNKNOWN`
            * :attr:`DSRuleState.STATE_ERROR`
            * :attr:`DSRuleState.STATE_IN_SYNC`
            * :attr:`DSRuleState.STATE_NOT_AVAILABLE`
            * :attr:`DSRuleState.STATE_VM_DEPLOYMENT_QUEUED`
            * :attr:`DSRuleState.STATE_VM_DEPLOYMENT_IN_PROGRESS`
            * :attr:`DSRuleState.STATE_VM_DEPLOYMENT_FAILED`
            * :attr:`DSRuleState.STATE_VM_POWER_ON_IN_PROGRESS`
            * :attr:`DSRuleState.STATE_VM_POWER_ON_FAILED`
            * :attr:`DSRuleState.STATE_REGISTRATION_PENDING`
            * :attr:`DSRuleState.STATE_NODE_NOT_READY`
            * :attr:`DSRuleState.STATE_NODE_READY`
            * :attr:`DSRuleState.STATE_VM_POWER_OFF_IN_PROGRESS`
            * :attr:`DSRuleState.STATE_VM_POWER_OFF_FAILED`
            * :attr:`DSRuleState.STATE_VM_UNDEPLOY_IN_PROGRESS`
            * :attr:`DSRuleState.STATE_VM_UNDEPLOY_FAILED`
            * :attr:`DSRuleState.STATE_VM_UNDEPLOY_SUCCESSFUL`
            * :attr:`DSRuleState.STATE_EDGE_CONFIG_ERROR`
            * :attr:`DSRuleState.STATE_VM_DEPLOYMENT_RESTARTED`
            * :attr:`DSRuleState.STATE_REGISTRATION_FAILED`
            * :attr:`DSRuleState.STATE_TRANSPORT_NODE_SYNC_PENDING`
            * :attr:`DSRuleState.STATE_TRANSPORT_NODE_CONFIGURATION_MISSING`
            * :attr:`DSRuleState.STATE_EDGE_HARDWARE_NOT_SUPPORTED`
            * :attr:`DSRuleState.STATE_MULTIPLE_OVERLAY_TZS_NOT_SUPPORTED`
            * :attr:`DSRuleState.STATE_TN_OVERLAY_TZ_IN_USE_BY_EDGE_CLUSTER`
            * :attr:`DSRuleState.STATE_TZ_ENDPOINTS_NOT_SPECIFIED`
            * :attr:`DSRuleState.STATE_NO_PNIC_PREPARED_IN_EDGE`
            * :attr:`DSRuleState.STATE_APPLIANCE_INTERNAL_ERROR`
            * :attr:`DSRuleState.STATE_VTEP_DHCP_NOT_SUPPORTED`
            * :attr:`DSRuleState.STATE_UNSUPPORTED_HOST_SWITCH_PROFILE`
            *
              :attr:`DSRuleState.STATE_UPLINK_HOST_SWITCH_PROFILE_NOT_SPECIFIED`
            * :attr:`DSRuleState.STATE_HOSTSWITCH_PROFILE_NOT_FOUND`
            * :attr:`DSRuleState.STATE_LLDP_SEND_ENABLED_NOT_SUPPORTED`
            * :attr:`DSRuleState.STATE_UNSUPPORTED_NAMED_TEAMING_POLICY`
            * :attr:`DSRuleState.STATE_LBSRCID_NOT_SUPPORTED_FOR_EDGE_VM`
            * :attr:`DSRuleState.STATE_LACP_NOT_SUPPORTED_FOR_EDGE_VM`
            *
              :attr:`DSRuleState.STATE_STANDBY_UPLINKS_NOT_SUPPORTED_FOR_EDGE_VM`
            *
              :attr:`DSRuleState.STATE_MULTIPLE_ACTIVE_UPLINKS_NOT_SUPPORTED_FOR_EDGE`
            * :attr:`DSRuleState.STATE_UNSUPPORTED_LACP_LB_ALGO_FOR_NODE`
            * :attr:`DSRuleState.STATE_EDGE_NODE_VERSION_NOT_SUPPORTED`
            * :attr:`DSRuleState.STATE_NO_PNIC_SPECIFIED_IN_TN`
            * :attr:`DSRuleState.STATE_INVALID_PNIC_DEVICE_NAME`
            * :attr:`DSRuleState.STATE_TRANSPORT_NODE_READY`
            * :attr:`DSRuleState.STATE_VM_NETWORK_EDIT_PENDING`
            * :attr:`DSRuleState.STATE_UNSUPPORTED_DEFAULT_TEAMING_POLICY`
            * :attr:`DSRuleState.STATE_MPA_DISCONNECTED`
            * :attr:`DSRuleState.STATE_VM_RENAME_PENDING`
            * :attr:`DSRuleState.STATE_VM_CONFIG_EDIT_PENDING`
            * :attr:`DSRuleState.STATE_VM_NETWORK_EDIT_FAILED`
            * :attr:`DSRuleState.STATE_VM_RENAME_FAILED`
            * :attr:`DSRuleState.STATE_VM_CONFIG_EDIT_FAILED`
            * :attr:`DSRuleState.STATE_VM_CONFIG_DISCREPANCY`
            * :attr:`DSRuleState.STATE_VM_NODE_REFRESH_FAILED`
            * :attr:`DSRuleState.STATE_VM_PLACEMENT_REFRESH_FAILED`
            * :attr:`DSRuleState.STATE_REGISTRATION_TIMEDOUT`
            
            Gives details of state of desired configuration. Additional enums
            with more details on progress/success/error states are sent for
            edge node. The success states are NODE_READY and
            TRANSPORT_NODE_READY, pending states are {VM_DEPLOYMENT_QUEUED,
            VM_DEPLOYMENT_IN_PROGRESS, REGISTRATION_PENDING} and other values
            indicate failures. \"in_sync\" state indicates that the desired
            configuration has been received by the host to which it applies,
            but is not yet in effect. When the configuration is actually in
            effect, the state will change to \"success\". Please note, failed
            state is deprecated.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  revision_desired: :class:`long` or ``None``
        :param revision_desired: This attribute represents revision number of rule's desired state.
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.details = details
        self.failure_code = failure_code
        self.failure_message = failure_message
        self.state = state
        self.revision_desired = revision_desired
        VapiStruct.__init__(self)


DSRuleState._set_binding_type(type.StructType(
    'com.vmware.nsx.model.DS_rule_state', {
        'details': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ConfigurationStateElement'))),
        'failure_code': type.OptionalType(type.IntegerType()),
        'failure_message': type.OptionalType(type.StringType()),
        'state': type.OptionalType(type.StringType()),
        'revision_desired': type.OptionalType(type.IntegerType()),
    },
    DSRuleState,
    False,
    None))



class DSSection(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    SECTION_TYPE_LAYER2 = "LAYER2"
    """


    """
    SECTION_TYPE_LAYER3 = "LAYER3"
    """


    """
    SECTION_TYPE_L3REDIRECT = "L3REDIRECT"
    """


    """
    SECTION_TYPE_IDS = "IDS"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'applied_tos': 'applied_tos',
                            'is_default': 'is_default',
                            'rule_count': 'rule_count',
                            'section_type': 'section_type',
                            'stateful': 'stateful',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 applied_tos=None,
                 is_default=None,
                 rule_count=None,
                 section_type=None,
                 stateful=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  applied_tos: :class:`list` of :class:`ResourceReference` or ``None``
        :param applied_tos: List of objects where the rules in this section will be enforced.
            This will take precedence over rule level appliedTo.
        :type  is_default: :class:`bool` or ``None``
        :param is_default: It is a boolean flag which reflects whether a distributed service
            section is default section or not. Each Layer 3 and Layer 2 section
            will have at least and at most one default section.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  rule_count: :class:`long` or ``None``
        :param rule_count: Number of rules in this section. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  section_type: :class:`str` or ``None``
        :param section_type: Possible values are: 
            
            * :attr:`DSSection.SECTION_TYPE_LAYER2`
            * :attr:`DSSection.SECTION_TYPE_LAYER3`
            * :attr:`DSSection.SECTION_TYPE_L3REDIRECT`
            * :attr:`DSSection.SECTION_TYPE_IDS`
            
            Type of the rules which a section can contain. Only homogeneous
            sections are supported.
        :type  stateful: :class:`bool` or ``None``
        :param stateful: Stateful or Stateless nature of distributed service section is
            enforced on all rules inside the section. Layer3 sections can be
            stateful or stateless. Layer2 sections can only be stateless.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.applied_tos = applied_tos
        self.is_default = is_default
        self.rule_count = rule_count
        self.section_type = section_type
        self.stateful = stateful
        VapiStruct.__init__(self)


DSSection._set_binding_type(type.StructType(
    'com.vmware.nsx.model.DS_section', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'applied_tos': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceReference'))),
        'is_default': type.OptionalType(type.BooleanType()),
        'rule_count': type.OptionalType(type.IntegerType()),
        'section_type': type.OptionalType(type.StringType()),
        'stateful': type.OptionalType(type.BooleanType()),
    },
    DSSection,
    False,
    None))



class DSSectionListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        VapiStruct.__init__(self)


DSSectionListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.DS_section_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
    },
    DSSectionListResult,
    False,
    None))



class DSSectionQueryParameters(VapiStruct):
    """
    Section query parameters

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'cascade': 'cascade',
                            }

    def __init__(self,
                 cascade=None,
                ):
        """
        :type  cascade: :class:`bool` or ``None``
        :param cascade: Flag to cascade delete of this object to all it's child objects.
        """
        self.cascade = cascade
        VapiStruct.__init__(self)


DSSectionQueryParameters._set_binding_type(type.StructType(
    'com.vmware.nsx.model.DS_section_query_parameters', {
        'cascade': type.OptionalType(type.BooleanType()),
    },
    DSSectionQueryParameters,
    False,
    None))



class DSSectionState(VapiStruct):
    """
    Section Realization Status

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATE_PENDING = "pending"
    """


    """
    STATE_IN_PROGRESS = "in_progress"
    """


    """
    STATE_SUCCESS = "success"
    """


    """
    STATE_FAILED = "failed"
    """


    """
    STATE_PARTIAL_SUCCESS = "partial_success"
    """


    """
    STATE_ORPHANED = "orphaned"
    """


    """
    STATE_UNKNOWN = "unknown"
    """


    """
    STATE_ERROR = "error"
    """


    """
    STATE_IN_SYNC = "in_sync"
    """


    """
    STATE_NOT_AVAILABLE = "NOT_AVAILABLE"
    """


    """
    STATE_VM_DEPLOYMENT_QUEUED = "VM_DEPLOYMENT_QUEUED"
    """


    """
    STATE_VM_DEPLOYMENT_IN_PROGRESS = "VM_DEPLOYMENT_IN_PROGRESS"
    """


    """
    STATE_VM_DEPLOYMENT_FAILED = "VM_DEPLOYMENT_FAILED"
    """


    """
    STATE_VM_POWER_ON_IN_PROGRESS = "VM_POWER_ON_IN_PROGRESS"
    """


    """
    STATE_VM_POWER_ON_FAILED = "VM_POWER_ON_FAILED"
    """


    """
    STATE_REGISTRATION_PENDING = "REGISTRATION_PENDING"
    """


    """
    STATE_NODE_NOT_READY = "NODE_NOT_READY"
    """


    """
    STATE_NODE_READY = "NODE_READY"
    """


    """
    STATE_VM_POWER_OFF_IN_PROGRESS = "VM_POWER_OFF_IN_PROGRESS"
    """


    """
    STATE_VM_POWER_OFF_FAILED = "VM_POWER_OFF_FAILED"
    """


    """
    STATE_VM_UNDEPLOY_IN_PROGRESS = "VM_UNDEPLOY_IN_PROGRESS"
    """


    """
    STATE_VM_UNDEPLOY_FAILED = "VM_UNDEPLOY_FAILED"
    """


    """
    STATE_VM_UNDEPLOY_SUCCESSFUL = "VM_UNDEPLOY_SUCCESSFUL"
    """


    """
    STATE_EDGE_CONFIG_ERROR = "EDGE_CONFIG_ERROR"
    """


    """
    STATE_VM_DEPLOYMENT_RESTARTED = "VM_DEPLOYMENT_RESTARTED"
    """


    """
    STATE_REGISTRATION_FAILED = "REGISTRATION_FAILED"
    """


    """
    STATE_TRANSPORT_NODE_SYNC_PENDING = "TRANSPORT_NODE_SYNC_PENDING"
    """


    """
    STATE_TRANSPORT_NODE_CONFIGURATION_MISSING = "TRANSPORT_NODE_CONFIGURATION_MISSING"
    """


    """
    STATE_EDGE_HARDWARE_NOT_SUPPORTED = "EDGE_HARDWARE_NOT_SUPPORTED"
    """


    """
    STATE_MULTIPLE_OVERLAY_TZS_NOT_SUPPORTED = "MULTIPLE_OVERLAY_TZS_NOT_SUPPORTED"
    """


    """
    STATE_TN_OVERLAY_TZ_IN_USE_BY_EDGE_CLUSTER = "TN_OVERLAY_TZ_IN_USE_BY_EDGE_CLUSTER"
    """


    """
    STATE_TZ_ENDPOINTS_NOT_SPECIFIED = "TZ_ENDPOINTS_NOT_SPECIFIED"
    """


    """
    STATE_NO_PNIC_PREPARED_IN_EDGE = "NO_PNIC_PREPARED_IN_EDGE"
    """


    """
    STATE_APPLIANCE_INTERNAL_ERROR = "APPLIANCE_INTERNAL_ERROR"
    """


    """
    STATE_VTEP_DHCP_NOT_SUPPORTED = "VTEP_DHCP_NOT_SUPPORTED"
    """


    """
    STATE_UNSUPPORTED_HOST_SWITCH_PROFILE = "UNSUPPORTED_HOST_SWITCH_PROFILE"
    """


    """
    STATE_UPLINK_HOST_SWITCH_PROFILE_NOT_SPECIFIED = "UPLINK_HOST_SWITCH_PROFILE_NOT_SPECIFIED"
    """


    """
    STATE_HOSTSWITCH_PROFILE_NOT_FOUND = "HOSTSWITCH_PROFILE_NOT_FOUND"
    """


    """
    STATE_LLDP_SEND_ENABLED_NOT_SUPPORTED = "LLDP_SEND_ENABLED_NOT_SUPPORTED"
    """


    """
    STATE_UNSUPPORTED_NAMED_TEAMING_POLICY = "UNSUPPORTED_NAMED_TEAMING_POLICY"
    """


    """
    STATE_LBSRCID_NOT_SUPPORTED_FOR_EDGE_VM = "LBSRCID_NOT_SUPPORTED_FOR_EDGE_VM"
    """


    """
    STATE_LACP_NOT_SUPPORTED_FOR_EDGE_VM = "LACP_NOT_SUPPORTED_FOR_EDGE_VM"
    """


    """
    STATE_STANDBY_UPLINKS_NOT_SUPPORTED_FOR_EDGE_VM = "STANDBY_UPLINKS_NOT_SUPPORTED_FOR_EDGE_VM"
    """


    """
    STATE_MULTIPLE_ACTIVE_UPLINKS_NOT_SUPPORTED_FOR_EDGE = "MULTIPLE_ACTIVE_UPLINKS_NOT_SUPPORTED_FOR_EDGE"
    """


    """
    STATE_UNSUPPORTED_LACP_LB_ALGO_FOR_NODE = "UNSUPPORTED_LACP_LB_ALGO_FOR_NODE"
    """


    """
    STATE_EDGE_NODE_VERSION_NOT_SUPPORTED = "EDGE_NODE_VERSION_NOT_SUPPORTED"
    """


    """
    STATE_NO_PNIC_SPECIFIED_IN_TN = "NO_PNIC_SPECIFIED_IN_TN"
    """


    """
    STATE_INVALID_PNIC_DEVICE_NAME = "INVALID_PNIC_DEVICE_NAME"
    """


    """
    STATE_TRANSPORT_NODE_READY = "TRANSPORT_NODE_READY"
    """


    """
    STATE_VM_NETWORK_EDIT_PENDING = "VM_NETWORK_EDIT_PENDING"
    """


    """
    STATE_UNSUPPORTED_DEFAULT_TEAMING_POLICY = "UNSUPPORTED_DEFAULT_TEAMING_POLICY"
    """


    """
    STATE_MPA_DISCONNECTED = "MPA_DISCONNECTED"
    """


    """
    STATE_VM_RENAME_PENDING = "VM_RENAME_PENDING"
    """


    """
    STATE_VM_CONFIG_EDIT_PENDING = "VM_CONFIG_EDIT_PENDING"
    """


    """
    STATE_VM_NETWORK_EDIT_FAILED = "VM_NETWORK_EDIT_FAILED"
    """


    """
    STATE_VM_RENAME_FAILED = "VM_RENAME_FAILED"
    """


    """
    STATE_VM_CONFIG_EDIT_FAILED = "VM_CONFIG_EDIT_FAILED"
    """


    """
    STATE_VM_CONFIG_DISCREPANCY = "VM_CONFIG_DISCREPANCY"
    """


    """
    STATE_VM_NODE_REFRESH_FAILED = "VM_NODE_REFRESH_FAILED"
    """


    """
    STATE_VM_PLACEMENT_REFRESH_FAILED = "VM_PLACEMENT_REFRESH_FAILED"
    """


    """
    STATE_REGISTRATION_TIMEDOUT = "REGISTRATION_TIMEDOUT"
    """


    """



    _canonical_to_pep_names = {
                            'details': 'details',
                            'failure_code': 'failure_code',
                            'failure_message': 'failure_message',
                            'state': 'state',
                            'revision_desired': 'revision_desired',
                            }

    def __init__(self,
                 details=None,
                 failure_code=None,
                 failure_message=None,
                 state=None,
                 revision_desired=None,
                ):
        """
        :type  details: :class:`list` of :class:`ConfigurationStateElement` or ``None``
        :param details: Array of configuration state of various sub systems
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  failure_code: :class:`long` or ``None``
        :param failure_code: Error code format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  failure_message: :class:`str` or ``None``
        :param failure_message: Error message in case of failure
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  state: :class:`str` or ``None``
        :param state: Possible values are: 
            
            * :attr:`DSSectionState.STATE_PENDING`
            * :attr:`DSSectionState.STATE_IN_PROGRESS`
            * :attr:`DSSectionState.STATE_SUCCESS`
            * :attr:`DSSectionState.STATE_FAILED`
            * :attr:`DSSectionState.STATE_PARTIAL_SUCCESS`
            * :attr:`DSSectionState.STATE_ORPHANED`
            * :attr:`DSSectionState.STATE_UNKNOWN`
            * :attr:`DSSectionState.STATE_ERROR`
            * :attr:`DSSectionState.STATE_IN_SYNC`
            * :attr:`DSSectionState.STATE_NOT_AVAILABLE`
            * :attr:`DSSectionState.STATE_VM_DEPLOYMENT_QUEUED`
            * :attr:`DSSectionState.STATE_VM_DEPLOYMENT_IN_PROGRESS`
            * :attr:`DSSectionState.STATE_VM_DEPLOYMENT_FAILED`
            * :attr:`DSSectionState.STATE_VM_POWER_ON_IN_PROGRESS`
            * :attr:`DSSectionState.STATE_VM_POWER_ON_FAILED`
            * :attr:`DSSectionState.STATE_REGISTRATION_PENDING`
            * :attr:`DSSectionState.STATE_NODE_NOT_READY`
            * :attr:`DSSectionState.STATE_NODE_READY`
            * :attr:`DSSectionState.STATE_VM_POWER_OFF_IN_PROGRESS`
            * :attr:`DSSectionState.STATE_VM_POWER_OFF_FAILED`
            * :attr:`DSSectionState.STATE_VM_UNDEPLOY_IN_PROGRESS`
            * :attr:`DSSectionState.STATE_VM_UNDEPLOY_FAILED`
            * :attr:`DSSectionState.STATE_VM_UNDEPLOY_SUCCESSFUL`
            * :attr:`DSSectionState.STATE_EDGE_CONFIG_ERROR`
            * :attr:`DSSectionState.STATE_VM_DEPLOYMENT_RESTARTED`
            * :attr:`DSSectionState.STATE_REGISTRATION_FAILED`
            * :attr:`DSSectionState.STATE_TRANSPORT_NODE_SYNC_PENDING`
            * :attr:`DSSectionState.STATE_TRANSPORT_NODE_CONFIGURATION_MISSING`
            * :attr:`DSSectionState.STATE_EDGE_HARDWARE_NOT_SUPPORTED`
            * :attr:`DSSectionState.STATE_MULTIPLE_OVERLAY_TZS_NOT_SUPPORTED`
            * :attr:`DSSectionState.STATE_TN_OVERLAY_TZ_IN_USE_BY_EDGE_CLUSTER`
            * :attr:`DSSectionState.STATE_TZ_ENDPOINTS_NOT_SPECIFIED`
            * :attr:`DSSectionState.STATE_NO_PNIC_PREPARED_IN_EDGE`
            * :attr:`DSSectionState.STATE_APPLIANCE_INTERNAL_ERROR`
            * :attr:`DSSectionState.STATE_VTEP_DHCP_NOT_SUPPORTED`
            * :attr:`DSSectionState.STATE_UNSUPPORTED_HOST_SWITCH_PROFILE`
            *
              :attr:`DSSectionState.STATE_UPLINK_HOST_SWITCH_PROFILE_NOT_SPECIFIED`
            * :attr:`DSSectionState.STATE_HOSTSWITCH_PROFILE_NOT_FOUND`
            * :attr:`DSSectionState.STATE_LLDP_SEND_ENABLED_NOT_SUPPORTED`
            * :attr:`DSSectionState.STATE_UNSUPPORTED_NAMED_TEAMING_POLICY`
            * :attr:`DSSectionState.STATE_LBSRCID_NOT_SUPPORTED_FOR_EDGE_VM`
            * :attr:`DSSectionState.STATE_LACP_NOT_SUPPORTED_FOR_EDGE_VM`
            *
              :attr:`DSSectionState.STATE_STANDBY_UPLINKS_NOT_SUPPORTED_FOR_EDGE_VM`
            *
              :attr:`DSSectionState.STATE_MULTIPLE_ACTIVE_UPLINKS_NOT_SUPPORTED_FOR_EDGE`
            * :attr:`DSSectionState.STATE_UNSUPPORTED_LACP_LB_ALGO_FOR_NODE`
            * :attr:`DSSectionState.STATE_EDGE_NODE_VERSION_NOT_SUPPORTED`
            * :attr:`DSSectionState.STATE_NO_PNIC_SPECIFIED_IN_TN`
            * :attr:`DSSectionState.STATE_INVALID_PNIC_DEVICE_NAME`
            * :attr:`DSSectionState.STATE_TRANSPORT_NODE_READY`
            * :attr:`DSSectionState.STATE_VM_NETWORK_EDIT_PENDING`
            * :attr:`DSSectionState.STATE_UNSUPPORTED_DEFAULT_TEAMING_POLICY`
            * :attr:`DSSectionState.STATE_MPA_DISCONNECTED`
            * :attr:`DSSectionState.STATE_VM_RENAME_PENDING`
            * :attr:`DSSectionState.STATE_VM_CONFIG_EDIT_PENDING`
            * :attr:`DSSectionState.STATE_VM_NETWORK_EDIT_FAILED`
            * :attr:`DSSectionState.STATE_VM_RENAME_FAILED`
            * :attr:`DSSectionState.STATE_VM_CONFIG_EDIT_FAILED`
            * :attr:`DSSectionState.STATE_VM_CONFIG_DISCREPANCY`
            * :attr:`DSSectionState.STATE_VM_NODE_REFRESH_FAILED`
            * :attr:`DSSectionState.STATE_VM_PLACEMENT_REFRESH_FAILED`
            * :attr:`DSSectionState.STATE_REGISTRATION_TIMEDOUT`
            
            Gives details of state of desired configuration. Additional enums
            with more details on progress/success/error states are sent for
            edge node. The success states are NODE_READY and
            TRANSPORT_NODE_READY, pending states are {VM_DEPLOYMENT_QUEUED,
            VM_DEPLOYMENT_IN_PROGRESS, REGISTRATION_PENDING} and other values
            indicate failures. \"in_sync\" state indicates that the desired
            configuration has been received by the host to which it applies,
            but is not yet in effect. When the configuration is actually in
            effect, the state will change to \"success\". Please note, failed
            state is deprecated.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  revision_desired: :class:`long` or ``None``
        :param revision_desired: This attribute represents revision number of section's desired
            state. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.details = details
        self.failure_code = failure_code
        self.failure_message = failure_message
        self.state = state
        self.revision_desired = revision_desired
        VapiStruct.__init__(self)


DSSectionState._set_binding_type(type.StructType(
    'com.vmware.nsx.model.DS_section_state', {
        'details': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ConfigurationStateElement'))),
        'failure_code': type.OptionalType(type.IntegerType()),
        'failure_message': type.OptionalType(type.StringType()),
        'state': type.OptionalType(type.StringType()),
        'revision_desired': type.OptionalType(type.IntegerType()),
    },
    DSSectionState,
    False,
    None))



class DSService(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'is_valid': 'is_valid',
                            'target_display_name': 'target_display_name',
                            'target_id': 'target_id',
                            'target_type': 'target_type',
                            'service': 'service',
                            }

    def __init__(self,
                 is_valid=None,
                 target_display_name=None,
                 target_id=None,
                 target_type=None,
                 service=None,
                ):
        """
        :type  is_valid: :class:`bool` or ``None``
        :param is_valid: Will be set to false if the referenced NSX resource has been
            deleted.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  target_display_name: :class:`str` or ``None``
        :param target_display_name: Display name of the NSX resource.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  target_id: :class:`str` or ``None``
        :param target_id: Identifier of the NSX resource.
        :type  target_type: :class:`str` or ``None``
        :param target_type: Type of the NSX resource.
        :type  service: :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param service: Distributed Service API accepts raw protocol and ports as part of
            NS service element in Distributed Service Rule that describes
            traffic corresponding to an NSService.
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`NSServiceElement`. When methods return a value of this
            class as a return value, the attribute will contain all the
            attributes defined in :class:`NSServiceElement`.
        """
        self.is_valid = is_valid
        self.target_display_name = target_display_name
        self.target_id = target_id
        self.target_type = target_type
        self.service = service
        VapiStruct.__init__(self)


DSService._set_binding_type(type.StructType(
    'com.vmware.nsx.model.DS_service', {
        'is_valid': type.OptionalType(type.BooleanType()),
        'target_display_name': type.OptionalType(type.StringType()),
        'target_id': type.OptionalType(type.StringType()),
        'target_type': type.OptionalType(type.StringType()),
        'service': type.OptionalType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'NSServiceElement')])),
    },
    DSService,
    False,
    None))



class DVSConfig(VapiStruct):
    """
    The DVS Configuration

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'host_infra_traffic_res': 'host_infra_traffic_res',
                            'lacp_group_configs': 'lacp_group_configs',
                            'lldp_send_enabled': 'lldp_send_enabled',
                            'mtu': 'mtu',
                            'name': 'name',
                            'uplink_port_names': 'uplink_port_names',
                            'uuid': 'uuid',
                            }

    def __init__(self,
                 host_infra_traffic_res=None,
                 lacp_group_configs=None,
                 lldp_send_enabled=None,
                 mtu=None,
                 name=None,
                 uplink_port_names=None,
                 uuid=None,
                ):
        """
        :type  host_infra_traffic_res: :class:`list` of :class:`ResourceAllocation` or ``None``
        :param host_infra_traffic_res: host_infra_traffic_res specifies bandwidth allocation for various
            traffic resources.
        :type  lacp_group_configs: :class:`list` of :class:`LacpGroupConfigInfo` or ``None``
        :param lacp_group_configs: It contains information about VMware specific multiple dynamic LACP
            groups.
        :type  lldp_send_enabled: :class:`bool` or ``None``
        :param lldp_send_enabled: Enabled or disabled sending LLDP packets
        :type  mtu: :class:`long` or ``None``
        :param mtu: Maximum Transmission Unit used for uplinks format: int32
        :type  name: :class:`str` or ``None``
        :param name: The DVS name
        :type  uplink_port_names: :class:`list` of :class:`str` or ``None``
        :param uplink_port_names: Names of uplink ports for this DVS.
        :type  uuid: :class:`str` or ``None``
        :param uuid: The DVS uuid
        """
        self.host_infra_traffic_res = host_infra_traffic_res
        self.lacp_group_configs = lacp_group_configs
        self.lldp_send_enabled = lldp_send_enabled
        self.mtu = mtu
        self.name = name
        self.uplink_port_names = uplink_port_names
        self.uuid = uuid
        VapiStruct.__init__(self)


DVSConfig._set_binding_type(type.StructType(
    'com.vmware.nsx.model.DVS_config', {
        'host_infra_traffic_res': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceAllocation'))),
        'lacp_group_configs': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'LacpGroupConfigInfo'))),
        'lldp_send_enabled': type.OptionalType(type.BooleanType()),
        'mtu': type.OptionalType(type.IntegerType()),
        'name': type.OptionalType(type.StringType()),
        'uplink_port_names': type.OptionalType(type.ListType(type.StringType())),
        'uuid': type.OptionalType(type.StringType()),
    },
    DVSConfig,
    False,
    None))



class DailyTelemetrySchedule(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'hour_of_day': 'hour_of_day',
                            'minutes': 'minutes',
                            'frequency_type': 'frequency_type',
                            }

    def __init__(self,
                 hour_of_day=None,
                 minutes=None,
                 frequency_type=None,
                ):
        """
        :type  hour_of_day: :class:`long` or ``None``
        :param hour_of_day: Hour at which data will be collected. Specify a value between 0
            through 23. format: int64
        :type  minutes: :class:`long` or ``None``
        :param minutes: Minute at which data will be collected. Specify a value between 0
            through 59. format: int64
        :type  frequency_type: :class:`str`
        :param frequency_type: Specify one of DailyTelemetrySchedule, WeeklyTelemetrySchedule, or
            MonthlyTelemetrySchedule.
        """
        self.hour_of_day = hour_of_day
        self.minutes = minutes
        self._frequency_type = frequency_type
        VapiStruct.__init__(self)

    @property
    def frequency_type(self):
        """
        Return the discriminator value
        """
        return self._frequency_type

DailyTelemetrySchedule._set_binding_type(type.StructType(
    'com.vmware.nsx.model.daily_telemetry_schedule', {
        'hour_of_day': type.OptionalType(type.IntegerType()),
        'minutes': type.OptionalType(type.IntegerType()),
        'frequency_type': type.StringType(),
    },
    DailyTelemetrySchedule,
    False,
    None))



class DataCounter(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'dropped': 'dropped',
                            'multicast_broadcast': 'multicast_broadcast',
                            'total': 'total',
                            }

    def __init__(self,
                 dropped=None,
                 multicast_broadcast=None,
                 total=None,
                ):
        """
        :type  dropped: :class:`long` or ``None``
        :param dropped: The dropped packets or bytes format: int64
        :type  multicast_broadcast: :class:`long` or ``None``
        :param multicast_broadcast: The multicast and broadcast packets or bytes format: int64
        :type  total: :class:`long` or ``None``
        :param total: The total packets or bytes format: int64
        """
        self.dropped = dropped
        self.multicast_broadcast = multicast_broadcast
        self.total = total
        VapiStruct.__init__(self)


DataCounter._set_binding_type(type.StructType(
    'com.vmware.nsx.model.data_counter', {
        'dropped': type.OptionalType(type.IntegerType()),
        'multicast_broadcast': type.OptionalType(type.IntegerType()),
        'total': type.OptionalType(type.IntegerType()),
    },
    DataCounter,
    False,
    None))



class DataTypeCollectionConfiguration(VapiStruct):
    """
    Data type collection configuration

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    DATA_TYPE_STATUS = "STATUS"
    """


    """
    DATA_TYPE_STATISTICS = "STATISTICS"
    """


    """



    _canonical_to_pep_names = {
                            'collection_frequency': 'collection_frequency',
                            'data_type': 'data_type',
                            }

    def __init__(self,
                 collection_frequency=None,
                 data_type=None,
                ):
        """
        :type  collection_frequency: :class:`long` or ``None``
        :param collection_frequency: The frequency in seconds at which data is collected format: int64
        :type  data_type: :class:`str` or ``None``
        :param data_type: Possible values are: 
            
            * :attr:`DataTypeCollectionConfiguration.DATA_TYPE_STATUS`
            * :attr:`DataTypeCollectionConfiguration.DATA_TYPE_STATISTICS`
            
             Defines the type of data being collected
        """
        self.collection_frequency = collection_frequency
        self.data_type = data_type
        VapiStruct.__init__(self)


DataTypeCollectionConfiguration._set_binding_type(type.StructType(
    'com.vmware.nsx.model.data_type_collection_configuration', {
        'collection_frequency': type.OptionalType(type.IntegerType()),
        'data_type': type.OptionalType(type.StringType()),
    },
    DataTypeCollectionConfiguration,
    False,
    None))



class Datasource(VapiStruct):
    """
    An instance of a datasource configuration.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'display_name': 'display_name',
                            'urls': 'urls',
                            }

    def __init__(self,
                 display_name=None,
                 urls=None,
                ):
        """
        :type  display_name: :class:`str` or ``None``
        :param display_name: Name of a datasource instance.
        :type  urls: :class:`list` of :class:`UrlAlias` or ``None``
        :param urls: Array of urls relative to the datasource configuration. For
            example, api/v1/fabric/nodes is a relative url of nsx-manager
            instance.
        """
        self.display_name = display_name
        self.urls = urls
        VapiStruct.__init__(self)


Datasource._set_binding_type(type.StructType(
    'com.vmware.nsx.model.datasource', {
        'display_name': type.OptionalType(type.StringType()),
        'urls': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'UrlAlias'))),
    },
    Datasource,
    False,
    None))



class DefaultFilterValue(VapiStruct):
    """
    An instance of a datasource configuration.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'alias': 'alias',
                            'value': 'value',
                            }

    def __init__(self,
                 alias=None,
                 value=None,
                ):
        """
        :type  alias: :class:`str` or ``None``
        :param alias: Filter alias.
        :type  value: :class:`str` or ``None``
        :param value: Filter default value.
        """
        self.alias = alias
        self.value = value
        VapiStruct.__init__(self)


DefaultFilterValue._set_binding_type(type.StructType(
    'com.vmware.nsx.model.default_filter_value', {
        'alias': type.OptionalType(type.StringType()),
        'value': type.OptionalType(type.StringType()),
    },
    DefaultFilterValue,
    False,
    None))



class DeploymentConfig(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "DeploymentConfig"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    PLACEMENT_TYPE_VSPHEREDEPLOYMENTCONFIG = "VsphereDeploymentConfig"
    """


    """



    _canonical_to_pep_names = {
                            'placement_type': 'placement_type',
                            }

    def __init__(self,
                 placement_type='DeploymentConfig',
                ):
        """
        :type  placement_type: :class:`str`
        :param placement_type: Possible values are: 
            
            * :attr:`DeploymentConfig.PLACEMENT_TYPE_VSPHEREDEPLOYMENTCONFIG`
        """
        self._placement_type = placement_type
        VapiStruct.__init__(self)

    @property
    def placement_type(self):
        """
        Return the discriminator value
        """
        return self._placement_type

DeploymentConfig._set_binding_type(type.StructType(
    'com.vmware.nsx.model.deployment_config', {
        'placement_type': type.StringType(),
    },
    DeploymentConfig,
    False,
    None))



class DeploymentSpecName(VapiStruct):
    """
    Used to provide the deployment spec for Upgrade.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'deployment_spec_name': 'deployment_spec_name',
                            }

    def __init__(self,
                 deployment_spec_name=None,
                ):
        """
        :type  deployment_spec_name: :class:`str` or ``None``
        :param deployment_spec_name: This indicates the deployment spec.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.deployment_spec_name = deployment_spec_name
        VapiStruct.__init__(self)


DeploymentSpecName._set_binding_type(type.StructType(
    'com.vmware.nsx.model.deployment_spec_name', {
        'deployment_spec_name': type.OptionalType(type.StringType()),
    },
    DeploymentSpecName,
    False,
    None))



class DeploymentTemplate(VapiStruct):
    """
    Deployment Template holds the attributes specific to partner for which the
    service is created. These attributes are opaque to NSX.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'attributes': 'attributes',
                            'name': 'name',
                            }

    def __init__(self,
                 attributes=None,
                 name=None,
                ):
        """
        :type  attributes: :class:`list` of :class:`Attribute` or ``None``
        :param attributes: List of attributes specific to a partner for which the service is
            created. There attributes are passed on to the partner appliance
            and is opaque to the NSX Manager.
        :type  name: :class:`str` or ``None``
        :param name: Deployment Template name.
        """
        self.attributes = attributes
        self.name = name
        VapiStruct.__init__(self)


DeploymentTemplate._set_binding_type(type.StructType(
    'com.vmware.nsx.model.deployment_template', {
        'attributes': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Attribute'))),
        'name': type.OptionalType(type.StringType()),
    },
    DeploymentTemplate,
    False,
    None))



class DestinationNsxApiEndpoint(VapiStruct):
    """
    Details about the destination NSX manager for the migration

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'destination_nsx_ip': 'destination_nsx_ip',
                            'destination_nsx_password': 'destination_nsx_password',
                            'destination_nsx_port': 'destination_nsx_port',
                            'destination_nsx_username': 'destination_nsx_username',
                            }

    def __init__(self,
                 destination_nsx_ip=None,
                 destination_nsx_password=None,
                 destination_nsx_port=None,
                 destination_nsx_username=None,
                ):
        """
        :type  destination_nsx_ip: :class:`str` or ``None``
        :param destination_nsx_ip: IP address or host name of the destination NSX manager to which the
            config will be migrated. format: hostname-or-ip
        :type  destination_nsx_password: :class:`str` or ``None``
        :param destination_nsx_password: Valid password for connecting to the destination NSX manager.
        :type  destination_nsx_port: :class:`long` or ``None``
        :param destination_nsx_port: Destination NSX manager port that will be used to apply details.
            format: int32
        :type  destination_nsx_username: :class:`str` or ``None``
        :param destination_nsx_username: Valid username for connecting to the destination NSX manager.
        """
        self.destination_nsx_ip = destination_nsx_ip
        self.destination_nsx_password = destination_nsx_password
        self.destination_nsx_port = destination_nsx_port
        self.destination_nsx_username = destination_nsx_username
        VapiStruct.__init__(self)


DestinationNsxApiEndpoint._set_binding_type(type.StructType(
    'com.vmware.nsx.model.destination_nsx_api_endpoint', {
        'destination_nsx_ip': type.OptionalType(type.StringType()),
        'destination_nsx_password': type.OptionalType(type.StringType()),
        'destination_nsx_port': type.OptionalType(type.IntegerType()),
        'destination_nsx_username': type.OptionalType(type.StringType()),
    },
    DestinationNsxApiEndpoint,
    False,
    None))



class DhcpFilter(VapiStruct):
    """
    DHCP filtering configuration

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'client_block_enabled': 'client_block_enabled',
                            'server_block_enabled': 'server_block_enabled',
                            'v6_client_block_enabled': 'v6_client_block_enabled',
                            'v6_server_block_enabled': 'v6_server_block_enabled',
                            }

    def __init__(self,
                 client_block_enabled=None,
                 server_block_enabled=None,
                 v6_client_block_enabled=None,
                 v6_server_block_enabled=None,
                ):
        """
        :type  client_block_enabled: :class:`bool` or ``None``
        :param client_block_enabled: Indicates whether DHCP client blocking is enabled
        :type  server_block_enabled: :class:`bool` or ``None``
        :param server_block_enabled: Indicates whether DHCP server blocking is enabled
        :type  v6_client_block_enabled: :class:`bool` or ``None``
        :param v6_client_block_enabled: Indiactes whether DHCP v6 client blocking is enabled
        :type  v6_server_block_enabled: :class:`bool` or ``None``
        :param v6_server_block_enabled: Indiactes whether DHCP V6 server blocking is enabled
        """
        self.client_block_enabled = client_block_enabled
        self.server_block_enabled = server_block_enabled
        self.v6_client_block_enabled = v6_client_block_enabled
        self.v6_server_block_enabled = v6_server_block_enabled
        VapiStruct.__init__(self)


DhcpFilter._set_binding_type(type.StructType(
    'com.vmware.nsx.model.dhcp_filter', {
        'client_block_enabled': type.OptionalType(type.BooleanType()),
        'server_block_enabled': type.OptionalType(type.BooleanType()),
        'v6_client_block_enabled': type.OptionalType(type.BooleanType()),
        'v6_server_block_enabled': type.OptionalType(type.BooleanType()),
    },
    DhcpFilter,
    False,
    None))



class DhcpHeader(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    OP_CODE_BOOTREQUEST = "BOOTREQUEST"
    """


    """
    OP_CODE_BOOTREPLY = "BOOTREPLY"
    """


    """



    _canonical_to_pep_names = {
                            'op_code': 'op_code',
                            }

    def __init__(self,
                 op_code=None,
                ):
        """
        :type  op_code: :class:`str` or ``None``
        :param op_code: Possible values are: 
            
            * :attr:`DhcpHeader.OP_CODE_BOOTREQUEST`
            * :attr:`DhcpHeader.OP_CODE_BOOTREPLY`
            
            This is used to specify the general type of message. A client
            sending request to a server uses an op code of BOOTREQUEST, while a
            server replying uses an op code of BOOTREPLY.
        """
        self.op_code = op_code
        VapiStruct.__init__(self)


DhcpHeader._set_binding_type(type.StructType(
    'com.vmware.nsx.model.dhcp_header', {
        'op_code': type.OptionalType(type.StringType()),
    },
    DhcpHeader,
    False,
    None))



class DhcpIpPool(VapiStruct):
    """
    DHCP ip-pool to define dynamic ip allocation ranges.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'gateway_ip': 'gateway_ip',
                            'lease_time': 'lease_time',
                            'options': 'options',
                            'allocation_ranges': 'allocation_ranges',
                            'error_threshold': 'error_threshold',
                            'warning_threshold': 'warning_threshold',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 gateway_ip=None,
                 lease_time=None,
                 options=None,
                 allocation_ranges=None,
                 error_threshold=None,
                 warning_threshold=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  gateway_ip: :class:`str` or ``None``
        :param gateway_ip: Gateway ip address of the allocation. format: ip
        :type  lease_time: :class:`long` or ``None``
        :param lease_time: Lease time, in seconds, [60-(2^32-1)]. Default is 86400. format:
            int64
        :type  options: :class:`DhcpOptions` or ``None``
        :param options: If an option is defined at server level and not configred at
            ip-pool/static-binding level, the option will be inherited to
            ip-pool/static-binding. If both define a same-code option, the
            option defined at ip-pool/static-binding level take precedence over
            that defined at server level.
        :type  allocation_ranges: :class:`list` of :class:`IpPoolRange` or ``None``
        :param allocation_ranges: Ip-ranges to define dynamic ip allocation ranges.
        :type  error_threshold: :class:`long` or ``None``
        :param error_threshold: Error threshold. Alert will be raised if the pool usage reaches the
            given threshold. format: int64
        :type  warning_threshold: :class:`long` or ``None``
        :param warning_threshold: Warning threshold. Alert will be raised if the pool usage reaches
            the given threshold. format: int64
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.gateway_ip = gateway_ip
        self.lease_time = lease_time
        self.options = options
        self.allocation_ranges = allocation_ranges
        self.error_threshold = error_threshold
        self.warning_threshold = warning_threshold
        VapiStruct.__init__(self)


DhcpIpPool._set_binding_type(type.StructType(
    'com.vmware.nsx.model.dhcp_ip_pool', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'gateway_ip': type.OptionalType(type.StringType()),
        'lease_time': type.OptionalType(type.IntegerType()),
        'options': type.OptionalType(type.ReferenceType(__name__, 'DhcpOptions')),
        'allocation_ranges': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IpPoolRange'))),
        'error_threshold': type.OptionalType(type.IntegerType()),
        'warning_threshold': type.OptionalType(type.IntegerType()),
    },
    DhcpIpPool,
    False,
    None))



class DhcpIpPoolListResult(VapiStruct):
    """
    A paginated list of DHCP ip pools.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`DhcpIpPool` or ``None``
        :param results: A paginated list of DHCP ip pools.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


DhcpIpPoolListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.dhcp_ip_pool_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'DhcpIpPool'))),
    },
    DhcpIpPoolListResult,
    False,
    None))



class DhcpIpPoolUsage(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'allocated_number': 'allocated_number',
                            'allocated_percentage': 'allocated_percentage',
                            'dhcp_ip_pool_id': 'dhcp_ip_pool_id',
                            'pool_size': 'pool_size',
                            }

    def __init__(self,
                 allocated_number=None,
                 allocated_percentage=None,
                 dhcp_ip_pool_id=None,
                 pool_size=None,
                ):
        """
        :type  allocated_number: :class:`long` or ``None``
        :param allocated_number: allocated number. COULD BE INACCURATE, REFERENCE ONLY. format:
            int64
        :type  allocated_percentage: :class:`long` or ``None``
        :param allocated_percentage: allocated percentage. COULD BE INACCURATE, REFERENCE ONLY. format:
            int64
        :type  dhcp_ip_pool_id: :class:`str` or ``None``
        :param dhcp_ip_pool_id: uuid of dhcp ip pool
        :type  pool_size: :class:`long` or ``None``
        :param pool_size: pool size format: int64
        """
        self.allocated_number = allocated_number
        self.allocated_percentage = allocated_percentage
        self.dhcp_ip_pool_id = dhcp_ip_pool_id
        self.pool_size = pool_size
        VapiStruct.__init__(self)


DhcpIpPoolUsage._set_binding_type(type.StructType(
    'com.vmware.nsx.model.dhcp_ip_pool_usage', {
        'allocated_number': type.OptionalType(type.IntegerType()),
        'allocated_percentage': type.OptionalType(type.IntegerType()),
        'dhcp_ip_pool_id': type.OptionalType(type.StringType()),
        'pool_size': type.OptionalType(type.IntegerType()),
    },
    DhcpIpPoolUsage,
    False,
    None))



class DhcpLeasePerIP(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'expire_time': 'expire_time',
                            'ip_address': 'ip_address',
                            'lease_time': 'lease_time',
                            'mac_address': 'mac_address',
                            'start_time': 'start_time',
                            'subnet': 'subnet',
                            }

    def __init__(self,
                 expire_time=None,
                 ip_address=None,
                 lease_time=None,
                 mac_address=None,
                 start_time=None,
                 subnet=None,
                ):
        """
        :type  expire_time: :class:`str` or ``None``
        :param expire_time: expire time of the lease
        :type  ip_address: :class:`str` or ``None``
        :param ip_address: ip address of client
        :type  lease_time: :class:`str` or ``None``
        :param lease_time: lease time of the ip address, in seconds
        :type  mac_address: :class:`str` or ``None``
        :param mac_address: mac address of client
        :type  start_time: :class:`str` or ``None``
        :param start_time: start time of lease
        :type  subnet: :class:`str` or ``None``
        :param subnet: subnet of client network
        """
        self.expire_time = expire_time
        self.ip_address = ip_address
        self.lease_time = lease_time
        self.mac_address = mac_address
        self.start_time = start_time
        self.subnet = subnet
        VapiStruct.__init__(self)


DhcpLeasePerIP._set_binding_type(type.StructType(
    'com.vmware.nsx.model.dhcp_lease_per_IP', {
        'expire_time': type.OptionalType(type.StringType()),
        'ip_address': type.OptionalType(type.StringType()),
        'lease_time': type.OptionalType(type.StringType()),
        'mac_address': type.OptionalType(type.StringType()),
        'start_time': type.OptionalType(type.StringType()),
        'subnet': type.OptionalType(type.StringType()),
    },
    DhcpLeasePerIP,
    False,
    None))



class DhcpLeases(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'dhcp_server_id': 'dhcp_server_id',
                            'leases': 'leases',
                            'timestamp': 'timestamp',
                            }

    def __init__(self,
                 dhcp_server_id=None,
                 leases=None,
                 timestamp=None,
                ):
        """
        :type  dhcp_server_id: :class:`str` or ``None``
        :param dhcp_server_id: dhcp server uuid
        :type  leases: :class:`list` of :class:`DhcpLeasePerIP` or ``None``
        :param leases: The lease info list of the server
        :type  timestamp: :class:`long` or ``None``
        :param timestamp: timestamp of the lease info format: int64
        """
        self.dhcp_server_id = dhcp_server_id
        self.leases = leases
        self.timestamp = timestamp
        VapiStruct.__init__(self)


DhcpLeases._set_binding_type(type.StructType(
    'com.vmware.nsx.model.dhcp_leases', {
        'dhcp_server_id': type.OptionalType(type.StringType()),
        'leases': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'DhcpLeasePerIP'))),
        'timestamp': type.OptionalType(type.IntegerType()),
    },
    DhcpLeases,
    False,
    None))



class DhcpOption121(VapiStruct):
    """
    DHCP option 121 to define classless static route.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'static_routes': 'static_routes',
                            }

    def __init__(self,
                 static_routes=None,
                ):
        """
        :type  static_routes: :class:`list` of :class:`ClasslessStaticRoute` or ``None``
        :param static_routes: Classless static route of DHCP option 121.
        """
        self.static_routes = static_routes
        VapiStruct.__init__(self)


DhcpOption121._set_binding_type(type.StructType(
    'com.vmware.nsx.model.dhcp_option121', {
        'static_routes': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ClasslessStaticRoute'))),
    },
    DhcpOption121,
    False,
    None))



class DhcpOptions(VapiStruct):
    """
    Define DHCP options of the DHCP service.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'option121': 'option121',
                            'others': 'others',
                            }

    def __init__(self,
                 option121=None,
                 others=None,
                ):
        """
        :type  option121: :class:`DhcpOption121` or ``None``
        :param option121: DHCP option 121 to define classless static routes. Once Option 121
            was defined, Option 249 will be auto-generated because they are
            equivalent.
        :type  others: :class:`list` of :class:`GenericDhcpOption` or ``None``
        :param others: To define DHCP options other than option 121 in generic format.
            Please note, only the following options can be defined in generic
            format. Those other options will be accepted without validation but
            will not take effect. -------------------------- Code Name
            -------------------------- 2 Time Offset 6 Domain Name Server 13
            Boot File Size 19 Forward On/Off 26 MTU Interface 28 Broadcast
            Address 35 ARP Timeout 40 NIS Domain 41 NIS Servers 42 NTP Servers
            44 NETBIOS Name Srv 45 NETBIOS Dist Srv 46 NETBIOS Node Type 47
            NETBIOS Scope 58 Renewal Time 59 Rebinding Time 64 NIS+-Domain-Name
            65 NIS+-Server-Addr 66 TFTP Server-Name (used by PXE) 67
            Bootfile-Name (used by PXE) 93 PXE: Client system architecture 94
            PXE: Client NDI 97 PXE: UUID/UNDI 117 Name Service Search 119
            Domain Search 150 TFTP server address (used by PXE) 175 Etherboot
            209 PXE Configuration File 210 PXE Path Prefix 211 PXE Reboot Time
        """
        self.option121 = option121
        self.others = others
        VapiStruct.__init__(self)


DhcpOptions._set_binding_type(type.StructType(
    'com.vmware.nsx.model.dhcp_options', {
        'option121': type.OptionalType(type.ReferenceType(__name__, 'DhcpOption121')),
        'others': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'GenericDhcpOption'))),
    },
    DhcpOptions,
    False,
    None))



class DhcpProfile(VapiStruct):
    """
    DHCP profile to specify edge cluster and members on which the dhcp server
    will run. A DhcpProfile can be referenced by different logical DHCP
    servers.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'edge_cluster_id': 'edge_cluster_id',
                            'edge_cluster_member_indexes': 'edge_cluster_member_indexes',
                            'enable_standby_relocation': 'enable_standby_relocation',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 edge_cluster_id=None,
                 edge_cluster_member_indexes=None,
                 enable_standby_relocation=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  edge_cluster_id: :class:`str` or ``None``
        :param edge_cluster_id: Edge cluster uuid on which the referencing logical DHCP server
            runs.
        :type  edge_cluster_member_indexes: :class:`list` of :class:`long` or ``None``
        :param edge_cluster_member_indexes: The Edge nodes on which the DHCP servers run. If none is provided,
            the NSX will auto-select two edge-nodes from the given edge
            cluster. If only one edge node is provided, the DHCP servers will
            run without HA support. format: int64
        :type  enable_standby_relocation: :class:`bool` or ``None``
        :param enable_standby_relocation: Flag to enable the auto-relocation of standby DHCP Service in case
            of edge node failure. Only tier 1 and auto placed DHCP servers are
            considered for the relocation.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.edge_cluster_id = edge_cluster_id
        self.edge_cluster_member_indexes = edge_cluster_member_indexes
        self.enable_standby_relocation = enable_standby_relocation
        VapiStruct.__init__(self)


DhcpProfile._set_binding_type(type.StructType(
    'com.vmware.nsx.model.dhcp_profile', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'edge_cluster_id': type.OptionalType(type.StringType()),
        'edge_cluster_member_indexes': type.OptionalType(type.ListType(type.IntegerType())),
        'enable_standby_relocation': type.OptionalType(type.BooleanType()),
    },
    DhcpProfile,
    False,
    None))



class DhcpProfileListResult(VapiStruct):
    """
    A paginated list of DHCP profiles.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`DhcpProfile` or ``None``
        :param results: A paginated list of logical DHCP profiles.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


DhcpProfileListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.dhcp_profile_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'DhcpProfile'))),
    },
    DhcpProfileListResult,
    False,
    None))



class DhcpRelayProfile(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'server_addresses': 'server_addresses',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 server_addresses=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  server_addresses: :class:`list` of :class:`str` or ``None``
        :param server_addresses: 
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.server_addresses = server_addresses
        VapiStruct.__init__(self)


DhcpRelayProfile._set_binding_type(type.StructType(
    'com.vmware.nsx.model.dhcp_relay_profile', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'server_addresses': type.OptionalType(type.ListType(type.StringType())),
    },
    DhcpRelayProfile,
    False,
    None))



class DhcpRelayProfileListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`DhcpRelayProfile` or ``None``
        :param results: Dhcp relay profile list results
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


DhcpRelayProfileListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.dhcp_relay_profile_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'DhcpRelayProfile'))),
    },
    DhcpRelayProfileListResult,
    False,
    None))



class DhcpRelayService(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'dhcp_relay_profile_id': 'dhcp_relay_profile_id',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 dhcp_relay_profile_id=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  dhcp_relay_profile_id: :class:`str` or ``None``
        :param dhcp_relay_profile_id: dhcp relay profile referenced by the dhcp relay service
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.dhcp_relay_profile_id = dhcp_relay_profile_id
        VapiStruct.__init__(self)


DhcpRelayService._set_binding_type(type.StructType(
    'com.vmware.nsx.model.dhcp_relay_service', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'dhcp_relay_profile_id': type.OptionalType(type.StringType()),
    },
    DhcpRelayService,
    False,
    None))



class DhcpRelayServiceListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`DhcpRelayService` or ``None``
        :param results: Dhcp relay service list results
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


DhcpRelayServiceListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.dhcp_relay_service_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'DhcpRelayService'))),
    },
    DhcpRelayServiceListResult,
    False,
    None))



class DhcpServerStatus(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    SERVICE_STATUS_UP = "UP"
    """


    """
    SERVICE_STATUS_DOWN = "DOWN"
    """


    """
    SERVICE_STATUS_ERROR = "ERROR"
    """


    """
    SERVICE_STATUS_NO_STANDBY = "NO_STANDBY"
    """


    """



    _canonical_to_pep_names = {
                            'active_node': 'active_node',
                            'error_message': 'error_message',
                            'service_status': 'service_status',
                            'stand_by_node': 'stand_by_node',
                            }

    def __init__(self,
                 active_node=None,
                 error_message=None,
                 service_status=None,
                 stand_by_node=None,
                ):
        """
        :type  active_node: :class:`str` or ``None``
        :param active_node: uuid of active transport node
        :type  error_message: :class:`str` or ``None``
        :param error_message: Error message, if available
        :type  service_status: :class:`str` or ``None``
        :param service_status: Possible values are: 
            
            * :attr:`DhcpServerStatus.SERVICE_STATUS_UP`
            * :attr:`DhcpServerStatus.SERVICE_STATUS_DOWN`
            * :attr:`DhcpServerStatus.SERVICE_STATUS_ERROR`
            * :attr:`DhcpServerStatus.SERVICE_STATUS_NO_STANDBY`
            
            UP means the dhcp service is working fine on both active
            transport-node and stand-by transport-node (if have), hence
            fail-over can work at this time if there is failure happens on one
            of the transport-node; DOWN means the dhcp service is down on both
            active transport-node and stand-by node (if have), hence the
            dhcp-service will not repsonse any dhcp request; Error means error
            happens on transport-node(s) or no status is reported from
            transport-node(s). The dhcp service may be working (or not
            working); NO_STANDBY means dhcp service is working in one of the
            transport node while not in the other transport-node (if have).
            Hence if the dhcp service in the working transport-node is down,
            fail-over will not happen and the dhcp service will go down.
        :type  stand_by_node: :class:`str` or ``None``
        :param stand_by_node: uuid of stand_by transport node. null if non-HA mode
        """
        self.active_node = active_node
        self.error_message = error_message
        self.service_status = service_status
        self.stand_by_node = stand_by_node
        VapiStruct.__init__(self)


DhcpServerStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.dhcp_server_status', {
        'active_node': type.OptionalType(type.StringType()),
        'error_message': type.OptionalType(type.StringType()),
        'service_status': type.OptionalType(type.StringType()),
        'stand_by_node': type.OptionalType(type.StringType()),
    },
    DhcpServerStatus,
    False,
    None))



class DhcpStaticBinding(VapiStruct):
    """
    DHCP static binding to define a static ip allocation.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'gateway_ip': 'gateway_ip',
                            'lease_time': 'lease_time',
                            'options': 'options',
                            'host_name': 'host_name',
                            'ip_address': 'ip_address',
                            'mac_address': 'mac_address',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 gateway_ip=None,
                 lease_time=None,
                 options=None,
                 host_name=None,
                 ip_address=None,
                 mac_address=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  gateway_ip: :class:`str` or ``None``
        :param gateway_ip: Gateway ip address of the allocation. format: ip
        :type  lease_time: :class:`long` or ``None``
        :param lease_time: Lease time, in seconds, [60-(2^32-1)]. Default is 86400. format:
            int64
        :type  options: :class:`DhcpOptions` or ``None``
        :param options: If an option is defined at server level and not configred at
            ip-pool/static-binding level, the option will be inherited to
            ip-pool/static-binding. If both define a same-code option, the
            option defined at ip-pool/static-binding level take precedence over
            that defined at server level.
        :type  host_name: :class:`str` or ``None``
        :param host_name: The host name to be assigned to the host. format: hostname
        :type  ip_address: :class:`str` or ``None``
        :param ip_address: The ip address to be assigned to the host. format: ip
        :type  mac_address: :class:`str` or ``None``
        :param mac_address: The MAC address of the host. format: mac-address
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.gateway_ip = gateway_ip
        self.lease_time = lease_time
        self.options = options
        self.host_name = host_name
        self.ip_address = ip_address
        self.mac_address = mac_address
        VapiStruct.__init__(self)


DhcpStaticBinding._set_binding_type(type.StructType(
    'com.vmware.nsx.model.dhcp_static_binding', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'gateway_ip': type.OptionalType(type.StringType()),
        'lease_time': type.OptionalType(type.IntegerType()),
        'options': type.OptionalType(type.ReferenceType(__name__, 'DhcpOptions')),
        'host_name': type.OptionalType(type.StringType()),
        'ip_address': type.OptionalType(type.StringType()),
        'mac_address': type.OptionalType(type.StringType()),
    },
    DhcpStaticBinding,
    False,
    None))



class DhcpStaticBindingListResult(VapiStruct):
    """
    A paginated list of DHCP static bindings.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`DhcpStaticBinding` or ``None``
        :param results: A paginated list of DHCP static bindings.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


DhcpStaticBindingListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.dhcp_static_binding_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'DhcpStaticBinding'))),
    },
    DhcpStaticBindingListResult,
    False,
    None))



class DhcpStatistics(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'acks': 'acks',
                            'declines': 'declines',
                            'dhcp_server_id': 'dhcp_server_id',
                            'discovers': 'discovers',
                            'errors': 'errors',
                            'informs': 'informs',
                            'ip_pool_stats': 'ip_pool_stats',
                            'nacks': 'nacks',
                            'offers': 'offers',
                            'releases': 'releases',
                            'requests': 'requests',
                            'timestamp': 'timestamp',
                            }

    def __init__(self,
                 acks=None,
                 declines=None,
                 dhcp_server_id=None,
                 discovers=None,
                 errors=None,
                 informs=None,
                 ip_pool_stats=None,
                 nacks=None,
                 offers=None,
                 releases=None,
                 requests=None,
                 timestamp=None,
                ):
        """
        :type  acks: :class:`long` or ``None``
        :param acks: The total number of DHCP ACK packets format: int64
        :type  declines: :class:`long` or ``None``
        :param declines: The total number of DHCP DECLINE packets format: int64
        :type  dhcp_server_id: :class:`str` or ``None``
        :param dhcp_server_id: dhcp server uuid
        :type  discovers: :class:`long` or ``None``
        :param discovers: The total number of DHCP DISCOVER packets format: int64
        :type  errors: :class:`long` or ``None``
        :param errors: The total number of DHCP errors format: int64
        :type  informs: :class:`long` or ``None``
        :param informs: The total number of DHCP INFORM packets format: int64
        :type  ip_pool_stats: :class:`list` of :class:`DhcpIpPoolUsage` or ``None``
        :param ip_pool_stats: The DHCP ip pool usage statistics
        :type  nacks: :class:`long` or ``None``
        :param nacks: The total number of DHCP NACK packets format: int64
        :type  offers: :class:`long` or ``None``
        :param offers: The total number of DHCP OFFER packets format: int64
        :type  releases: :class:`long` or ``None``
        :param releases: The total number of DHCP RELEASE packets format: int64
        :type  requests: :class:`long` or ``None``
        :param requests: The total number of DHCP REQUEST packets format: int64
        :type  timestamp: :class:`long` or ``None``
        :param timestamp: timestamp of the statistics format: int64
        """
        self.acks = acks
        self.declines = declines
        self.dhcp_server_id = dhcp_server_id
        self.discovers = discovers
        self.errors = errors
        self.informs = informs
        self.ip_pool_stats = ip_pool_stats
        self.nacks = nacks
        self.offers = offers
        self.releases = releases
        self.requests = requests
        self.timestamp = timestamp
        VapiStruct.__init__(self)


DhcpStatistics._set_binding_type(type.StructType(
    'com.vmware.nsx.model.dhcp_statistics', {
        'acks': type.OptionalType(type.IntegerType()),
        'declines': type.OptionalType(type.IntegerType()),
        'dhcp_server_id': type.OptionalType(type.StringType()),
        'discovers': type.OptionalType(type.IntegerType()),
        'errors': type.OptionalType(type.IntegerType()),
        'informs': type.OptionalType(type.IntegerType()),
        'ip_pool_stats': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'DhcpIpPoolUsage'))),
        'nacks': type.OptionalType(type.IntegerType()),
        'offers': type.OptionalType(type.IntegerType()),
        'releases': type.OptionalType(type.IntegerType()),
        'requests': type.OptionalType(type.IntegerType()),
        'timestamp': type.OptionalType(type.IntegerType()),
    },
    DhcpStatistics,
    False,
    None))



class DhcpV6InfoBase(VapiStruct):
    """
    Base type of IPv6 ip-allocation extended by ip-pool and static-binding.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'dns_nameservers': 'dns_nameservers',
                            'domain_names': 'domain_names',
                            'lease_time': 'lease_time',
                            'preferred_time': 'preferred_time',
                            'sntp_servers': 'sntp_servers',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 dns_nameservers=None,
                 domain_names=None,
                 lease_time=None,
                 preferred_time=None,
                 sntp_servers=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  dns_nameservers: :class:`list` of :class:`str` or ``None``
        :param dns_nameservers: Primary and secondary DNS server address to assign host. They can
            be overridden by ip-pool or static-binding level property. format:
            ipv6
        :type  domain_names: :class:`list` of :class:`str` or ``None``
        :param domain_names: Host name or prefix to be assigned to host. It can be overridden by
            ip-pool or static-binding level property.
        :type  lease_time: :class:`long` or ``None``
        :param lease_time: Lease time, in seconds. format: int64
        :type  preferred_time: :class:`long` or ``None``
        :param preferred_time: Preferred time, in seconds. If this value is not provided, the
            value of lease_time\*0.8 will be used. format: int64
        :type  sntp_servers: :class:`list` of :class:`str` or ``None``
        :param sntp_servers: SNTP server ips. format: ipv6
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.dns_nameservers = dns_nameservers
        self.domain_names = domain_names
        self.lease_time = lease_time
        self.preferred_time = preferred_time
        self.sntp_servers = sntp_servers
        VapiStruct.__init__(self)


DhcpV6InfoBase._set_binding_type(type.StructType(
    'com.vmware.nsx.model.dhcp_v6_info_base', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'dns_nameservers': type.OptionalType(type.ListType(type.StringType())),
        'domain_names': type.OptionalType(type.ListType(type.StringType())),
        'lease_time': type.OptionalType(type.IntegerType()),
        'preferred_time': type.OptionalType(type.IntegerType()),
        'sntp_servers': type.OptionalType(type.ListType(type.StringType())),
    },
    DhcpV6InfoBase,
    False,
    None))



class DhcpV6IpPool(VapiStruct):
    """
    DHCP IPv6 ip pool to define dynamic ip allocation ranges. The DhcpV6IpPool
    would only provide stateless DHCP (domain search list, DNS servers, SNTP
    servers) to client if both the ranges and excluded_ranges are not
    specified.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'dns_nameservers': 'dns_nameservers',
                            'domain_names': 'domain_names',
                            'lease_time': 'lease_time',
                            'preferred_time': 'preferred_time',
                            'sntp_servers': 'sntp_servers',
                            'excluded_ranges': 'excluded_ranges',
                            'ranges': 'ranges',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 dns_nameservers=None,
                 domain_names=None,
                 lease_time=None,
                 preferred_time=None,
                 sntp_servers=None,
                 excluded_ranges=None,
                 ranges=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  dns_nameservers: :class:`list` of :class:`str` or ``None``
        :param dns_nameservers: Primary and secondary DNS server address to assign host. They can
            be overridden by ip-pool or static-binding level property. format:
            ipv6
        :type  domain_names: :class:`list` of :class:`str` or ``None``
        :param domain_names: Host name or prefix to be assigned to host. It can be overridden by
            ip-pool or static-binding level property.
        :type  lease_time: :class:`long` or ``None``
        :param lease_time: Lease time, in seconds. format: int64
        :type  preferred_time: :class:`long` or ``None``
        :param preferred_time: Preferred time, in seconds. If this value is not provided, the
            value of lease_time\*0.8 will be used. format: int64
        :type  sntp_servers: :class:`list` of :class:`str` or ``None``
        :param sntp_servers: SNTP server ips. format: ipv6
        :type  excluded_ranges: :class:`list` of :class:`IpPoolRange` or ``None``
        :param excluded_ranges: Excluded addresses to define dynamic ip allocation ranges.
        :type  ranges: :class:`list` of :class:`IpPoolRange` or ``None``
        :param ranges: Ip address ranges to define dynamic ip allocation ranges.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.dns_nameservers = dns_nameservers
        self.domain_names = domain_names
        self.lease_time = lease_time
        self.preferred_time = preferred_time
        self.sntp_servers = sntp_servers
        self.excluded_ranges = excluded_ranges
        self.ranges = ranges
        VapiStruct.__init__(self)


DhcpV6IpPool._set_binding_type(type.StructType(
    'com.vmware.nsx.model.dhcp_v6_ip_pool', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'dns_nameservers': type.OptionalType(type.ListType(type.StringType())),
        'domain_names': type.OptionalType(type.ListType(type.StringType())),
        'lease_time': type.OptionalType(type.IntegerType()),
        'preferred_time': type.OptionalType(type.IntegerType()),
        'sntp_servers': type.OptionalType(type.ListType(type.StringType())),
        'excluded_ranges': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IpPoolRange'))),
        'ranges': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IpPoolRange'))),
    },
    DhcpV6IpPool,
    False,
    None))



class DhcpV6IpPoolListResult(VapiStruct):
    """
    A paginated list of DHCP IPv6 ip pools.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`DhcpV6IpPool` or ``None``
        :param results: A paginated list of DHCP IPv6 ip pools.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


DhcpV6IpPoolListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.dhcp_v6_ip_pool_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'DhcpV6IpPool'))),
    },
    DhcpV6IpPoolListResult,
    False,
    None))



class DhcpV6StaticBinding(VapiStruct):
    """
    DHCP IPv6 static binding to define a static ip allocation.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'dns_nameservers': 'dns_nameservers',
                            'domain_names': 'domain_names',
                            'lease_time': 'lease_time',
                            'preferred_time': 'preferred_time',
                            'sntp_servers': 'sntp_servers',
                            'ip_addresses': 'ip_addresses',
                            'mac_address': 'mac_address',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 dns_nameservers=None,
                 domain_names=None,
                 lease_time=None,
                 preferred_time=None,
                 sntp_servers=None,
                 ip_addresses=None,
                 mac_address=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  dns_nameservers: :class:`list` of :class:`str` or ``None``
        :param dns_nameservers: Primary and secondary DNS server address to assign host. They can
            be overridden by ip-pool or static-binding level property. format:
            ipv6
        :type  domain_names: :class:`list` of :class:`str` or ``None``
        :param domain_names: Host name or prefix to be assigned to host. It can be overridden by
            ip-pool or static-binding level property.
        :type  lease_time: :class:`long` or ``None``
        :param lease_time: Lease time, in seconds. format: int64
        :type  preferred_time: :class:`long` or ``None``
        :param preferred_time: Preferred time, in seconds. If this value is not provided, the
            value of lease_time\*0.8 will be used. format: int64
        :type  sntp_servers: :class:`list` of :class:`str` or ``None``
        :param sntp_servers: SNTP server ips. format: ipv6
        :type  ip_addresses: :class:`list` of :class:`str` or ``None``
        :param ip_addresses: When not specified, no ip address will be assigned to client host.
            format: ipv6
        :type  mac_address: :class:`str` or ``None``
        :param mac_address: The MAC address of the host. Either client-duid or mac-address, but
            not both. format: mac-address
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.dns_nameservers = dns_nameservers
        self.domain_names = domain_names
        self.lease_time = lease_time
        self.preferred_time = preferred_time
        self.sntp_servers = sntp_servers
        self.ip_addresses = ip_addresses
        self.mac_address = mac_address
        VapiStruct.__init__(self)


DhcpV6StaticBinding._set_binding_type(type.StructType(
    'com.vmware.nsx.model.dhcp_v6_static_binding', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'dns_nameservers': type.OptionalType(type.ListType(type.StringType())),
        'domain_names': type.OptionalType(type.ListType(type.StringType())),
        'lease_time': type.OptionalType(type.IntegerType()),
        'preferred_time': type.OptionalType(type.IntegerType()),
        'sntp_servers': type.OptionalType(type.ListType(type.StringType())),
        'ip_addresses': type.OptionalType(type.ListType(type.StringType())),
        'mac_address': type.OptionalType(type.StringType()),
    },
    DhcpV6StaticBinding,
    False,
    None))



class DhcpV6StaticBindingListResult(VapiStruct):
    """
    A paginated list of DHCP IPv6 static bindings.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`DhcpV6StaticBinding` or ``None``
        :param results: A paginated list of DHCP IPv6 static bindings.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


DhcpV6StaticBindingListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.dhcp_v6_static_binding_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'DhcpV6StaticBinding'))),
    },
    DhcpV6StaticBindingListResult,
    False,
    None))



class Dhcpv6Header(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    MSG_TYPE_SOLICIT = "SOLICIT"
    """


    """
    MSG_TYPE_ADVERTISE = "ADVERTISE"
    """


    """
    MSG_TYPE_REQUEST = "REQUEST"
    """


    """
    MSG_TYPE_REPLY = "REPLY"
    """


    """



    _canonical_to_pep_names = {
                            'msg_type': 'msg_type',
                            }

    def __init__(self,
                 msg_type=None,
                ):
        """
        :type  msg_type: :class:`str` or ``None``
        :param msg_type: Possible values are: 
            
            * :attr:`Dhcpv6Header.MSG_TYPE_SOLICIT`
            * :attr:`Dhcpv6Header.MSG_TYPE_ADVERTISE`
            * :attr:`Dhcpv6Header.MSG_TYPE_REQUEST`
            * :attr:`Dhcpv6Header.MSG_TYPE_REPLY`
            
            This is used to specify the DHCP v6 message. To request the
            assignment of one or more IPv6 addresses, a client first locates a
            DHCP server and then requests the assignment of addresses and other
            configuration information from the server. The client sends a
            Solicit message to the All_DHCP_Relay_Agents_and_Servers address to
            find available DHCP servers. Any server that can meet the client's
            requirements responds with an Advertise message. The client then
            chooses one of the servers and sends a Request message to the
            server asking for confirmed assignment of addresses and other
            configuration information. The server responds with a Reply message
            that contains the confirmed addresses and configuration. SOLICIT -
            A client sends a Solicit message to locate servers. ADVERTISE - A
            server sends and Advertise message to indicate that it is
            available. REQUEST - A client sends a Request message to request
            configuration parameters. REPLY - A server sends a Reply message
            containing assigned addresses and configuration parameters.
        """
        self.msg_type = msg_type
        VapiStruct.__init__(self)


Dhcpv6Header._set_binding_type(type.StructType(
    'com.vmware.nsx.model.dhcpv6_header', {
        'msg_type': type.OptionalType(type.StringType()),
    },
    Dhcpv6Header,
    False,
    None))



class DirectoryAdDomain(VapiStruct):
    """
    Active Directory Domain

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "DirectoryAdDomain"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'base_distinguished_name': 'base_distinguished_name',
                            'netbios_name': 'netbios_name',
                            'selective_sync_settings': 'selective_sync_settings',
                            'sync_settings': 'sync_settings',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'ldap_servers': 'ldap_servers',
                            'name': 'name',
                            }

    def __init__(self,
                 base_distinguished_name=None,
                 netbios_name=None,
                 selective_sync_settings=None,
                 sync_settings=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='DirectoryAdDomain',
                 tags=None,
                 ldap_servers=None,
                 name=None,
                ):
        """
        :type  base_distinguished_name: :class:`str` or ``None``
        :param base_distinguished_name: Each active directory domain has a domain naming context (NC),
            which contains domain-specific data. The root of this naming
            context is represented by a domain's distinguished name (DN) and is
            typically referred to as the NC head.
        :type  netbios_name: :class:`str` or ``None``
        :param netbios_name: NetBIOS names can contain all alphanumeric characters except for
            the certain disallowed characters. Names can contain a period, but
            names cannot start with a period. NetBIOS is similar to DNS in that
            it can serve as a directory service, but more limited as it has no
            provisions for a name hierarchy and names are limited to 15
            characters. The netbios name is case insensitive and is stored in
            upper case regardless of input case.
        :type  selective_sync_settings: :class:`SelectiveSyncSettings` or ``None``
        :param selective_sync_settings: SelectiveSync settings toggle the SelectiveSync feature and
            selected OrgUnits. If this is not specified, SelectiveSync is
            disabled by default.
        :type  sync_settings: :class:`DirectoryDomainSyncSettings` or ``None``
        :param sync_settings: Each domain sync settings can be changed using this object. It is
            not required since there are default values used if there is no
            specification for this object.
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`DirectoryDomain.RESOURCE_TYPE_DIRECTORYADDOMAIN`
            
            Domain resource type comes from multiple sub-classes extending this
            base class. For example, DirectoryAdDomain is one accepted
            resource_type. If there are more sub-classes defined, they will
            also be accepted resource_type.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  ldap_servers: :class:`list` of :class:`DirectoryLdapServer` or ``None``
        :param ldap_servers: Directory domain LDAP servers' information including host, name,
            port, protocol and so on.
        :type  name: :class:`str` or ``None``
        :param name: Directory domain name which best describes the domain. It could be
            unique fqdn name or it could also be descriptive. There is no
            unique contraint for domain name among different domains.
        """
        self.base_distinguished_name = base_distinguished_name
        self.netbios_name = netbios_name
        self.selective_sync_settings = selective_sync_settings
        self.sync_settings = sync_settings
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        self.ldap_servers = ldap_servers
        self.name = name
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

DirectoryAdDomain._set_binding_type(type.StructType(
    'com.vmware.nsx.model.directory_ad_domain', {
        'base_distinguished_name': type.OptionalType(type.StringType()),
        'netbios_name': type.OptionalType(type.StringType()),
        'selective_sync_settings': type.OptionalType(type.ReferenceType(__name__, 'SelectiveSyncSettings')),
        'sync_settings': type.OptionalType(type.ReferenceType(__name__, 'DirectoryDomainSyncSettings')),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'ldap_servers': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'DirectoryLdapServer'))),
        'name': type.OptionalType(type.StringType()),
    },
    DirectoryAdDomain,
    False,
    None))



class DirectoryAdGroup(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'object_guid': 'object_guid',
                            'secure_id': 'secure_id',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'distinguished_name': 'distinguished_name',
                            'domain_id': 'domain_id',
                            'domain_name': 'domain_name',
                            'domain_sync_node_id': 'domain_sync_node_id',
                            }

    def __init__(self,
                 object_guid=None,
                 secure_id=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 distinguished_name=None,
                 domain_id=None,
                 domain_name=None,
                 domain_sync_node_id=None,
                ):
        """
        :type  object_guid: :class:`str` or ``None``
        :param object_guid: GUID is a 128-bit value that is unique not only in the enterprise
            but also across the world. GUIDs are assigned to every object
            created by Active Directory, not just User and Group objects.
        :type  secure_id: :class:`str` or ``None``
        :param secure_id: A security identifier (SID) is a unique value of variable length
            used to identify a trustee. A SID consists of the following
            components - The revision level of the SID structure; A 48-bit
            identifier authority value that identifies the authority that
            issued the SID; A variable number of subauthority or relative
            identifier (RID) values that uniquely identify the trustee relative
            to the authority that issued the SID.
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Directory group resource type comes from multiple sub-classes
            extending this base class. For example, DirectoryAdGroup is one
            accepted resource_type. If there are more sub-classes defined, they
            will also be accepted resource_type.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  distinguished_name: :class:`str` or ``None``
        :param distinguished_name: Directory group distinguished name
        :type  domain_id: :class:`str` or ``None``
        :param domain_id: Domain ID this directory group belongs to.
        :type  domain_name: :class:`str` or ``None``
        :param domain_name: Each active directory domain has a domain naming context (NC),
            which contains domain-specific data. The root of this naming
            context is represented by a domain's distinguished name (DN) and is
            typically referred to as the NC head.
        :type  domain_sync_node_id: :class:`str` or ``None``
        :param domain_sync_node_id: Domain sync node under which this directory group is located. We
            currently sync only from Root node and hence this attribute doesn't
            have a specific value set.
        """
        self.object_guid = object_guid
        self.secure_id = secure_id
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        self.distinguished_name = distinguished_name
        self.domain_id = domain_id
        self.domain_name = domain_name
        self.domain_sync_node_id = domain_sync_node_id
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

DirectoryAdGroup._set_binding_type(type.StructType(
    'com.vmware.nsx.model.directory_ad_group', {
        'object_guid': type.OptionalType(type.StringType()),
        'secure_id': type.OptionalType(type.StringType()),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'distinguished_name': type.OptionalType(type.StringType()),
        'domain_id': type.OptionalType(type.StringType()),
        'domain_name': type.OptionalType(type.StringType()),
        'domain_sync_node_id': type.OptionalType(type.StringType()),
    },
    DirectoryAdGroup,
    False,
    None))



class DirectoryDomain(VapiStruct):
    """
    Directory Domain

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "DirectoryDomain"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    RESOURCE_TYPE_DIRECTORYADDOMAIN = "DirectoryAdDomain"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'ldap_servers': 'ldap_servers',
                            'name': 'name',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='DirectoryDomain',
                 tags=None,
                 ldap_servers=None,
                 name=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`DirectoryDomain.RESOURCE_TYPE_DIRECTORYADDOMAIN`
            
            Domain resource type comes from multiple sub-classes extending this
            base class. For example, DirectoryAdDomain is one accepted
            resource_type. If there are more sub-classes defined, they will
            also be accepted resource_type.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  ldap_servers: :class:`list` of :class:`DirectoryLdapServer` or ``None``
        :param ldap_servers: Directory domain LDAP servers' information including host, name,
            port, protocol and so on.
        :type  name: :class:`str` or ``None``
        :param name: Directory domain name which best describes the domain. It could be
            unique fqdn name or it could also be descriptive. There is no
            unique contraint for domain name among different domains.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        self.ldap_servers = ldap_servers
        self.name = name
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

DirectoryDomain._set_binding_type(type.StructType(
    'com.vmware.nsx.model.directory_domain', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'ldap_servers': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'DirectoryLdapServer'))),
        'name': type.OptionalType(type.StringType()),
    },
    DirectoryDomain,
    False,
    None))



class DirectoryDomainListResults(VapiStruct):
    """
    List of Directory Domain

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param results: List of Directory Domains
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`DirectoryDomain`. When methods return a value of this class
            as a return value, the attribute will contain all the attributes
            defined in :class:`DirectoryDomain`.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


DirectoryDomainListResults._set_binding_type(type.StructType(
    'com.vmware.nsx.model.directory_domain_list_results', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'DirectoryDomain')]))),
    },
    DirectoryDomainListResults,
    False,
    None))



class DirectoryDomainSize(VapiStruct):
    """
    Size of Directory Domain

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'group_count': 'group_count',
                            'group_member_count': 'group_member_count',
                            'user_count': 'user_count',
                            }

    def __init__(self,
                 group_count=None,
                 group_member_count=None,
                 user_count=None,
                ):
        """
        :type  group_count: :class:`long` or ``None``
        :param group_count: Number of groups format: int32
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  group_member_count: :class:`long` or ``None``
        :param group_member_count: Number of group members format: int32
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  user_count: :class:`long` or ``None``
        :param user_count: Number of users format: int32
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.group_count = group_count
        self.group_member_count = group_member_count
        self.user_count = user_count
        VapiStruct.__init__(self)


DirectoryDomainSize._set_binding_type(type.StructType(
    'com.vmware.nsx.model.directory_domain_size', {
        'group_count': type.OptionalType(type.IntegerType()),
        'group_member_count': type.OptionalType(type.IntegerType()),
        'user_count': type.OptionalType(type.IntegerType()),
    },
    DirectoryDomainSize,
    False,
    None))



class DirectoryDomainSyncSettings(VapiStruct):
    """
    Domain synchronization settings

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'delta_sync_interval': 'delta_sync_interval',
                            'full_sync_cron_expr': 'full_sync_cron_expr',
                            'sync_delay_in_sec': 'sync_delay_in_sec',
                            }

    def __init__(self,
                 delta_sync_interval=None,
                 full_sync_cron_expr=None,
                 sync_delay_in_sec=None,
                ):
        """
        :type  delta_sync_interval: :class:`long` or ``None``
        :param delta_sync_interval: Directory domain delta synchronization interval time between two
            delta sync in minutes. format: int64
        :type  full_sync_cron_expr: :class:`str` or ``None``
        :param full_sync_cron_expr: Directory domain full synchronization schedule using cron
            expression. For example, cron expression \"0 0 12 ? \* SUN \*\"
            means full sync is scheduled every Sunday midnight. If this object
            is null, it means there is no background cron job running for full
            sync.
        :type  sync_delay_in_sec: :class:`long` or ``None``
        :param sync_delay_in_sec: Sync delay after Directory domain has been successfully created. if
            delay is -1, initial full sync will not be triggered. format: int32
        """
        self.delta_sync_interval = delta_sync_interval
        self.full_sync_cron_expr = full_sync_cron_expr
        self.sync_delay_in_sec = sync_delay_in_sec
        VapiStruct.__init__(self)


DirectoryDomainSyncSettings._set_binding_type(type.StructType(
    'com.vmware.nsx.model.directory_domain_sync_settings', {
        'delta_sync_interval': type.OptionalType(type.IntegerType()),
        'full_sync_cron_expr': type.OptionalType(type.StringType()),
        'sync_delay_in_sec': type.OptionalType(type.IntegerType()),
    },
    DirectoryDomainSyncSettings,
    False,
    None))



class DirectoryDomainSyncStats(VapiStruct):
    """
    Directory domain synchronization statistics

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    CURRENT_STATE_IDLE = "IDLE"
    """


    """
    CURRENT_STATE_FULL_SYNC = "FULL_SYNC"
    """


    """
    CURRENT_STATE_DELTA_SYNC = "DELTA_SYNC"
    """


    """
    CURRENT_STATE_SELECTIVE_FULL_SYNC = "SELECTIVE_FULL_SYNC"
    """


    """
    CURRENT_STATE_SELECTIVE_DELTA_SYNC = "SELECTIVE_DELTA_SYNC"
    """


    """
    PREV_SYNC_STATUS_SUCCESS = "SUCCESS"
    """


    """
    PREV_SYNC_STATUS_FAILURE = "FAILURE"
    """


    """
    PREV_SYNC_STATUS_UNKNOWN = "UNKNOWN"
    """


    """
    PREV_SYNC_TYPE_IDLE = "IDLE"
    """


    """
    PREV_SYNC_TYPE_FULL_SYNC = "FULL_SYNC"
    """


    """
    PREV_SYNC_TYPE_DELTA_SYNC = "DELTA_SYNC"
    """


    """
    PREV_SYNC_TYPE_SELECTIVE_FULL_SYNC = "SELECTIVE_FULL_SYNC"
    """


    """
    PREV_SYNC_TYPE_SELECTIVE_DELTA_SYNC = "SELECTIVE_DELTA_SYNC"
    """


    """



    _canonical_to_pep_names = {
                            'avg_delta_sync_time': 'avg_delta_sync_time',
                            'avg_full_sync_time': 'avg_full_sync_time',
                            'current_state': 'current_state',
                            'current_state_begin_time': 'current_state_begin_time',
                            'num_delta_sync': 'num_delta_sync',
                            'num_full_sync': 'num_full_sync',
                            'prev_sync_end_time': 'prev_sync_end_time',
                            'prev_sync_error': 'prev_sync_error',
                            'prev_sync_status': 'prev_sync_status',
                            'prev_sync_type': 'prev_sync_type',
                            }

    def __init__(self,
                 avg_delta_sync_time=None,
                 avg_full_sync_time=None,
                 current_state=None,
                 current_state_begin_time=None,
                 num_delta_sync=None,
                 num_full_sync=None,
                 prev_sync_end_time=None,
                 prev_sync_error=None,
                 prev_sync_status=None,
                 prev_sync_type=None,
                ):
        """
        :type  avg_delta_sync_time: :class:`long` or ``None``
        :param avg_delta_sync_time: All the historical delta sync are counted in calculating the
            average delta sync time in milliseconds. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  avg_full_sync_time: :class:`long` or ``None``
        :param avg_full_sync_time: All the historical full sync are counted in calculating the average
            full sync time in milliseconds. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  current_state: :class:`str` or ``None``
        :param current_state: Possible values are: 
            
            * :attr:`DirectoryDomainSyncStats.CURRENT_STATE_IDLE`
            * :attr:`DirectoryDomainSyncStats.CURRENT_STATE_FULL_SYNC`
            * :attr:`DirectoryDomainSyncStats.CURRENT_STATE_DELTA_SYNC`
            *
              :attr:`DirectoryDomainSyncStats.CURRENT_STATE_SELECTIVE_FULL_SYNC`
            *
              :attr:`DirectoryDomainSyncStats.CURRENT_STATE_SELECTIVE_DELTA_SYNC`
            
            Current running state of the directory domain in synchronization
            life cycle. It could be one of the following five states.
            SELECTIVE_FULL_SYNC and SELECTIVE_DELTA_SYNC are sync states for
            selective sync.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  current_state_begin_time: :class:`long` or ``None``
        :param current_state_begin_time: Since what time the current state has begun. The time is expressed
            in millisecond epoch time. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  num_delta_sync: :class:`long` or ``None``
        :param num_delta_sync: number of successful historical delta sync initiated either by
            system or by API request. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  num_full_sync: :class:`long` or ``None``
        :param num_full_sync: number of successful historical full sync initiated either by
            system or by API request. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  prev_sync_end_time: :class:`long` or ``None``
        :param prev_sync_end_time: Directory domain previous sync ending time expressed in millisecond
            epoch time. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  prev_sync_error: :class:`str` or ``None``
        :param prev_sync_error: Directory domain previous sync status error if last status was
            failure.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  prev_sync_status: :class:`str` or ``None``
        :param prev_sync_status: Possible values are: 
            
            * :attr:`DirectoryDomainSyncStats.PREV_SYNC_STATUS_SUCCESS`
            * :attr:`DirectoryDomainSyncStats.PREV_SYNC_STATUS_FAILURE`
            * :attr:`DirectoryDomainSyncStats.PREV_SYNC_STATUS_UNKNOWN`
            
            Directory domain previous sync status. It could be one of the
            following two states.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  prev_sync_type: :class:`str` or ``None``
        :param prev_sync_type: Possible values are: 
            
            * :attr:`DirectoryDomainSyncStats.PREV_SYNC_TYPE_IDLE`
            * :attr:`DirectoryDomainSyncStats.PREV_SYNC_TYPE_FULL_SYNC`
            * :attr:`DirectoryDomainSyncStats.PREV_SYNC_TYPE_DELTA_SYNC`
            *
              :attr:`DirectoryDomainSyncStats.PREV_SYNC_TYPE_SELECTIVE_FULL_SYNC`
            *
              :attr:`DirectoryDomainSyncStats.PREV_SYNC_TYPE_SELECTIVE_DELTA_SYNC`
            
            Directory domain previous sync type. It could be one of the
            following five states. Right after the directory domain is
            configured, this field is set to IDLE.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.avg_delta_sync_time = avg_delta_sync_time
        self.avg_full_sync_time = avg_full_sync_time
        self.current_state = current_state
        self.current_state_begin_time = current_state_begin_time
        self.num_delta_sync = num_delta_sync
        self.num_full_sync = num_full_sync
        self.prev_sync_end_time = prev_sync_end_time
        self.prev_sync_error = prev_sync_error
        self.prev_sync_status = prev_sync_status
        self.prev_sync_type = prev_sync_type
        VapiStruct.__init__(self)


DirectoryDomainSyncStats._set_binding_type(type.StructType(
    'com.vmware.nsx.model.directory_domain_sync_stats', {
        'avg_delta_sync_time': type.OptionalType(type.IntegerType()),
        'avg_full_sync_time': type.OptionalType(type.IntegerType()),
        'current_state': type.OptionalType(type.StringType()),
        'current_state_begin_time': type.OptionalType(type.IntegerType()),
        'num_delta_sync': type.OptionalType(type.IntegerType()),
        'num_full_sync': type.OptionalType(type.IntegerType()),
        'prev_sync_end_time': type.OptionalType(type.IntegerType()),
        'prev_sync_error': type.OptionalType(type.StringType()),
        'prev_sync_status': type.OptionalType(type.StringType()),
        'prev_sync_type': type.OptionalType(type.StringType()),
    },
    DirectoryDomainSyncStats,
    False,
    None))



class DirectoryGroup(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "DirectoryGroup"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'distinguished_name': 'distinguished_name',
                            'domain_id': 'domain_id',
                            'domain_name': 'domain_name',
                            'domain_sync_node_id': 'domain_sync_node_id',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='DirectoryGroup',
                 tags=None,
                 distinguished_name=None,
                 domain_id=None,
                 domain_name=None,
                 domain_sync_node_id=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Directory group resource type comes from multiple sub-classes
            extending this base class. For example, DirectoryAdGroup is one
            accepted resource_type. If there are more sub-classes defined, they
            will also be accepted resource_type.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  distinguished_name: :class:`str` or ``None``
        :param distinguished_name: Directory group distinguished name
        :type  domain_id: :class:`str` or ``None``
        :param domain_id: Domain ID this directory group belongs to.
        :type  domain_name: :class:`str` or ``None``
        :param domain_name: Each active directory domain has a domain naming context (NC),
            which contains domain-specific data. The root of this naming
            context is represented by a domain's distinguished name (DN) and is
            typically referred to as the NC head.
        :type  domain_sync_node_id: :class:`str` or ``None``
        :param domain_sync_node_id: Domain sync node under which this directory group is located. We
            currently sync only from Root node and hence this attribute doesn't
            have a specific value set.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        self.distinguished_name = distinguished_name
        self.domain_id = domain_id
        self.domain_name = domain_name
        self.domain_sync_node_id = domain_sync_node_id
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

DirectoryGroup._set_binding_type(type.StructType(
    'com.vmware.nsx.model.directory_group', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'distinguished_name': type.OptionalType(type.StringType()),
        'domain_id': type.OptionalType(type.StringType()),
        'domain_name': type.OptionalType(type.StringType()),
        'domain_sync_node_id': type.OptionalType(type.StringType()),
    },
    DirectoryGroup,
    False,
    None))



class DirectoryGroupListResults(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param results: Directory group list
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`DirectoryGroup`. When methods return a value of this class
            as a return value, the attribute will contain all the attributes
            defined in :class:`DirectoryGroup`.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


DirectoryGroupListResults._set_binding_type(type.StructType(
    'com.vmware.nsx.model.directory_group_list_results', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'DirectoryGroup')]))),
    },
    DirectoryGroupListResults,
    False,
    None))



class DirectoryGroupMember(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'group_distinguished_name': 'group_distinguished_name',
                            'group_id': 'group_id',
                            'member_group_distinguished_name': 'member_group_distinguished_name',
                            'member_group_id': 'member_group_id',
                            'nested': 'nested',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 group_distinguished_name=None,
                 group_id=None,
                 member_group_distinguished_name=None,
                 member_group_id=None,
                 nested=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  group_distinguished_name: :class:`str` or ``None``
        :param group_distinguished_name: Directory group distinguished name this group member belongs to.
        :type  group_id: :class:`str` or ``None``
        :param group_id: Directory group id this group member belongs to
        :type  member_group_distinguished_name: :class:`str` or ``None``
        :param member_group_distinguished_name: Directory group name this group member owns
        :type  member_group_id: :class:`str` or ``None``
        :param member_group_id: Directory group id this group member owns
        :type  nested: :class:`bool` or ``None``
        :param nested: Whether this member group is a directory member of the parent group
            speicified by group_id or a nested member group which parent group
            is also member group of the parent group speicified by group_id.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.group_distinguished_name = group_distinguished_name
        self.group_id = group_id
        self.member_group_distinguished_name = member_group_distinguished_name
        self.member_group_id = member_group_id
        self.nested = nested
        VapiStruct.__init__(self)


DirectoryGroupMember._set_binding_type(type.StructType(
    'com.vmware.nsx.model.directory_group_member', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'group_distinguished_name': type.OptionalType(type.StringType()),
        'group_id': type.OptionalType(type.StringType()),
        'member_group_distinguished_name': type.OptionalType(type.StringType()),
        'member_group_id': type.OptionalType(type.StringType()),
        'nested': type.OptionalType(type.BooleanType()),
    },
    DirectoryGroupMember,
    False,
    None))



class DirectoryGroupMemberListResults(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`DirectoryGroupMember` or ``None``
        :param results: Directory group member list
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


DirectoryGroupMemberListResults._set_binding_type(type.StructType(
    'com.vmware.nsx.model.directory_group_member_list_results', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'DirectoryGroupMember'))),
    },
    DirectoryGroupMemberListResults,
    False,
    None))



class DirectoryLdapServer(VapiStruct):
    """
    LDAP server of directory domain

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    PROTOCOL_LDAP = "LDAP"
    """


    """
    PROTOCOL_LDAPS = "LDAPS"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'domain_name': 'domain_name',
                            'host': 'host',
                            'password': 'password',
                            'port': 'port',
                            'protocol': 'protocol',
                            'thumbprint': 'thumbprint',
                            'username': 'username',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 domain_name=None,
                 host=None,
                 password=None,
                 port=None,
                 protocol=None,
                 thumbprint=None,
                 username=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  domain_name: :class:`str` or ``None``
        :param domain_name: Directory domain name which best describes the domain. It could be
            unique fqdn name or it could also be descriptive. There is no
            unique contraint for domain name among different domains.
        :type  host: :class:`str` or ``None``
        :param host: Directory LDAP server DNS host name or ip address which is
            reachable by NSX manager to be connected and do object
            synchronization. format: ip-or-hostname
        :type  password: :class:`str` or ``None``
        :param password: Directory LDAP server connection password.
        :type  port: :class:`long` or ``None``
        :param port: Directory LDAP server connection TCP/UDP port. format: int64
        :type  protocol: :class:`str` or ``None``
        :param protocol: Possible values are: 
            
            * :attr:`DirectoryLdapServer.PROTOCOL_LDAP`
            * :attr:`DirectoryLdapServer.PROTOCOL_LDAPS`
            
            Directory LDAP server connection protocol which is either LDAP or
            LDAPS.
        :type  thumbprint: :class:`str` or ``None``
        :param thumbprint: Directory LDAP server certificate thumbprint used in secure LDAPS
            connection.
        :type  username: :class:`str` or ``None``
        :param username: Directory LDAP server connection user name.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.domain_name = domain_name
        self.host = host
        self.password = password
        self.port = port
        self.protocol = protocol
        self.thumbprint = thumbprint
        self.username = username
        VapiStruct.__init__(self)


DirectoryLdapServer._set_binding_type(type.StructType(
    'com.vmware.nsx.model.directory_ldap_server', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'domain_name': type.OptionalType(type.StringType()),
        'host': type.OptionalType(type.StringType()),
        'password': type.OptionalType(type.StringType()),
        'port': type.OptionalType(type.IntegerType()),
        'protocol': type.OptionalType(type.StringType()),
        'thumbprint': type.OptionalType(type.StringType()),
        'username': type.OptionalType(type.StringType()),
    },
    DirectoryLdapServer,
    False,
    None))



class DirectoryLdapServerListResults(VapiStruct):
    """
    List of directory domain LDAP servers

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`DirectoryLdapServer` or ``None``
        :param results: List of directory domain LDAP servers
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


DirectoryLdapServerListResults._set_binding_type(type.StructType(
    'com.vmware.nsx.model.directory_ldap_server_list_results', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'DirectoryLdapServer'))),
    },
    DirectoryLdapServerListResults,
    False,
    None))



class DirectoryLdapServerStatus(VapiStruct):
    """
    Status LDAP server of directory domain

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'error_id': 'error_id',
                            'error_message': 'error_message',
                            }

    def __init__(self,
                 error_id=None,
                 error_message=None,
                ):
        """
        :type  error_id: :class:`long` or ``None``
        :param error_id: Error ID of the directory LDAP server status maintained by the NSX
            directory service. format: int64
        :type  error_message: :class:`str` or ``None``
        :param error_message: Error message of the directory LDAP server status maintained by the
            NSX directory service.
        """
        self.error_id = error_id
        self.error_message = error_message
        VapiStruct.__init__(self)


DirectoryLdapServerStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.directory_ldap_server_status', {
        'error_id': type.OptionalType(type.IntegerType()),
        'error_message': type.OptionalType(type.StringType()),
    },
    DirectoryLdapServerStatus,
    False,
    None))



class DiscoveredNode(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "DiscoveredNode"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'certificate': 'certificate',
                            'cm_local_id': 'cm_local_id',
                            'external_id': 'external_id',
                            'hardware_id': 'hardware_id',
                            'ip_addresses': 'ip_addresses',
                            'node_type': 'node_type',
                            'origin_id': 'origin_id',
                            'origin_properties': 'origin_properties',
                            'os_type': 'os_type',
                            'os_version': 'os_version',
                            'parent_compute_collection': 'parent_compute_collection',
                            'stateless': 'stateless',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_last_sync_time': 'last_sync_time',
                            'description': 'description',
                            'display_name': 'display_name',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            }

    def __init__(self,
                 certificate=None,
                 cm_local_id=None,
                 external_id=None,
                 hardware_id=None,
                 ip_addresses=None,
                 node_type=None,
                 origin_id=None,
                 origin_properties=None,
                 os_type=None,
                 os_version=None,
                 parent_compute_collection=None,
                 stateless=None,
                 links=None,
                 schema=None,
                 self_=None,
                 last_sync_time=None,
                 description=None,
                 display_name=None,
                 resource_type='DiscoveredNode',
                 tags=None,
                ):
        """
        :type  certificate: :class:`str` or ``None``
        :param certificate: Certificate of the discovered node
        :type  cm_local_id: :class:`str` or ``None``
        :param cm_local_id: Local Id of the discovered node in the Compute Manager
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  external_id: :class:`str` or ``None``
        :param external_id: External id of the discovered node, ex. a mo-ref from VC
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  hardware_id: :class:`str` or ``None``
        :param hardware_id: Hardware Id is generated using system hardware info. It is used to
            retrieve fabric node of the esx.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  ip_addresses: :class:`list` of :class:`str` or ``None``
        :param ip_addresses: IP Addresses of the the discovered node. format: ip
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  node_type: :class:`str` or ``None``
        :param node_type: Discovered Node type like Host
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  origin_id: :class:`str` or ``None``
        :param origin_id: Id of the compute manager from where this node was discovered
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  origin_properties: :class:`list` of :class:`KeyValuePair` or ``None``
        :param origin_properties: Key-Value map of additional specific properties of discovered node
            in the Compute Manager
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  os_type: :class:`str` or ``None``
        :param os_type: OS type of the discovered node
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  os_version: :class:`str` or ``None``
        :param os_version: OS version of the discovered node
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  parent_compute_collection: :class:`str` or ``None``
        :param parent_compute_collection: External id of the compute collection to which this node belongs
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  stateless: :class:`bool` or ``None``
        :param stateless: The stateless property describes whether host persists its state
            across reboot or not. If state persists, value is set as false
            otherwise true.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  last_sync_time: :class:`long` or ``None``
        :param last_sync_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  resource_type: :class:`str`
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        """
        self.certificate = certificate
        self.cm_local_id = cm_local_id
        self.external_id = external_id
        self.hardware_id = hardware_id
        self.ip_addresses = ip_addresses
        self.node_type = node_type
        self.origin_id = origin_id
        self.origin_properties = origin_properties
        self.os_type = os_type
        self.os_version = os_version
        self.parent_compute_collection = parent_compute_collection
        self.stateless = stateless
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.last_sync_time = last_sync_time
        self.description = description
        self.display_name = display_name
        self._resource_type = resource_type
        self.tags = tags
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

DiscoveredNode._set_binding_type(type.StructType(
    'com.vmware.nsx.model.discovered_node', {
        'certificate': type.OptionalType(type.StringType()),
        'cm_local_id': type.OptionalType(type.StringType()),
        'external_id': type.OptionalType(type.StringType()),
        'hardware_id': type.OptionalType(type.StringType()),
        'ip_addresses': type.OptionalType(type.ListType(type.StringType())),
        'node_type': type.OptionalType(type.StringType()),
        'origin_id': type.OptionalType(type.StringType()),
        'origin_properties': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'KeyValuePair'))),
        'os_type': type.OptionalType(type.StringType()),
        'os_version': type.OptionalType(type.StringType()),
        'parent_compute_collection': type.OptionalType(type.StringType()),
        'stateless': type.OptionalType(type.BooleanType()),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_last_sync_time': type.OptionalType(type.IntegerType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
    },
    DiscoveredNode,
    False,
    None))



class DiscoveredNodeInterfaceProperties(VapiStruct):
    """
    Network interface properties of discovered node

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    CONNECTED_SWITCH_TYPE_VSS = "VSS"
    """


    """
    CONNECTED_SWITCH_TYPE_DVS = "DVS"
    """


    """
    CONNECTED_SWITCH_TYPE_N_VDS = "N-VDS"
    """


    """



    _canonical_to_pep_names = {
                            'connected_switch': 'connected_switch',
                            'connected_switch_type': 'connected_switch_type',
                            'interface_id': 'interface_id',
                            'physical_address': 'physical_address',
                            }

    def __init__(self,
                 connected_switch=None,
                 connected_switch_type=None,
                 interface_id=None,
                 physical_address=None,
                ):
        """
        :type  connected_switch: :class:`str` or ``None``
        :param connected_switch: Switch name which is connected to nic, switch can be opaque,
            proxyHostSwitch or virtual
        :type  connected_switch_type: :class:`str` or ``None``
        :param connected_switch_type: Possible values are: 
            
            *
              :attr:`DiscoveredNodeInterfaceProperties.CONNECTED_SWITCH_TYPE_VSS`
            *
              :attr:`DiscoveredNodeInterfaceProperties.CONNECTED_SWITCH_TYPE_DVS`
            *
              :attr:`DiscoveredNodeInterfaceProperties.CONNECTED_SWITCH_TYPE_N_VDS`
            
             Type of virtual switch can be VSS, DVS or N-VDS.
        :type  interface_id: :class:`str` or ``None``
        :param interface_id: Id of the network interface
        :type  physical_address: :class:`str` or ``None``
        :param physical_address: Mac address of the interface format: mac-address
        """
        self.connected_switch = connected_switch
        self.connected_switch_type = connected_switch_type
        self.interface_id = interface_id
        self.physical_address = physical_address
        VapiStruct.__init__(self)


DiscoveredNodeInterfaceProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.discovered_node_interface_properties', {
        'connected_switch': type.OptionalType(type.StringType()),
        'connected_switch_type': type.OptionalType(type.StringType()),
        'interface_id': type.OptionalType(type.StringType()),
        'physical_address': type.OptionalType(type.StringType()),
    },
    DiscoveredNodeInterfaceProperties,
    False,
    None))



class DiscoveredNodeListResult(VapiStruct):
    """
    Discovered Node list result

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`DiscoveredNode` or ``None``
        :param results: Discovered Node list results
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


DiscoveredNodeListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.discovered_node_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'DiscoveredNode'))),
    },
    DiscoveredNodeListResult,
    False,
    None))



class DiscoveredNodeNetworkInterfaces(VapiStruct):
    """
    All the network interfaces of the discovered node

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'discovered_node_id': 'discovered_node_id',
                            'network_interfaces': 'network_interfaces',
                            }

    def __init__(self,
                 discovered_node_id=None,
                 network_interfaces=None,
                ):
        """
        :type  discovered_node_id: :class:`str` or ``None``
        :param discovered_node_id: Id of the discovered node
        :type  network_interfaces: :class:`list` of :class:`DiscoveredNodeInterfaceProperties` or ``None``
        :param network_interfaces: Network interfaces of the node
        """
        self.discovered_node_id = discovered_node_id
        self.network_interfaces = network_interfaces
        VapiStruct.__init__(self)


DiscoveredNodeNetworkInterfaces._set_binding_type(type.StructType(
    'com.vmware.nsx.model.discovered_node_network_interfaces', {
        'discovered_node_id': type.OptionalType(type.StringType()),
        'network_interfaces': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'DiscoveredNodeInterfaceProperties'))),
    },
    DiscoveredNodeNetworkInterfaces,
    False,
    None))



class DiscoveredResource(VapiStruct):
    """
    Base class for resources that are discovered and automatically updated

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "DiscoveredResource"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_last_sync_time': 'last_sync_time',
                            'description': 'description',
                            'display_name': 'display_name',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 last_sync_time=None,
                 description=None,
                 display_name=None,
                 resource_type='DiscoveredResource',
                 tags=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  last_sync_time: :class:`long` or ``None``
        :param last_sync_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  resource_type: :class:`str`
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.last_sync_time = last_sync_time
        self.description = description
        self.display_name = display_name
        self._resource_type = resource_type
        self.tags = tags
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

DiscoveredResource._set_binding_type(type.StructType(
    'com.vmware.nsx.model.discovered_resource', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_last_sync_time': type.OptionalType(type.IntegerType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
    },
    DiscoveredResource,
    False,
    None))



class DistributedVirtualPortgroup(VapiStruct):
    """
    Distributed virtual portgroup on a VC

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    OVERALL_STATUS_RED = "RED"
    """


    """
    OVERALL_STATUS_YELLOW = "YELLOW"
    """


    """
    OVERALL_STATUS_GREEN = "GREEN"
    """


    """
    OVERALL_STATUS_GRAY = "GRAY"
    """


    """



    _canonical_to_pep_names = {
                            'backing_type': 'backing_type',
                            'key': 'key',
                            'overall_status': 'overall_status',
                            'cm_local_id': 'cm_local_id',
                            'external_id': 'external_id',
                            'origin_type': 'origin_type',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_last_sync_time': 'last_sync_time',
                            'description': 'description',
                            'display_name': 'display_name',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            }

    def __init__(self,
                 backing_type=None,
                 key=None,
                 overall_status=None,
                 cm_local_id=None,
                 external_id=None,
                 origin_type=None,
                 links=None,
                 schema=None,
                 self_=None,
                 last_sync_time=None,
                 description=None,
                 display_name=None,
                 resource_type=None,
                 tags=None,
                ):
        """
        :type  backing_type: :class:`str` or ``None``
        :param backing_type: For distributed virtual portgroup, backing type is standard. For
            logical switch portgroup, the backing type is set to nsx.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  key: :class:`str` or ``None``
        :param key: Generated UUID of the portgroup
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  overall_status: :class:`str` or ``None``
        :param overall_status: Possible values are: 
            
            * :attr:`DistributedVirtualPortgroup.OVERALL_STATUS_RED`
            * :attr:`DistributedVirtualPortgroup.OVERALL_STATUS_YELLOW`
            * :attr:`DistributedVirtualPortgroup.OVERALL_STATUS_GREEN`
            * :attr:`DistributedVirtualPortgroup.OVERALL_STATUS_GRAY`
            
            This parameters reflects the managed entity status of the portgroup
            as reported by VC.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  cm_local_id: :class:`str` or ``None``
        :param cm_local_id: Id of the portgroup, eg. a mo-ref from VC.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  external_id: :class:`str` or ``None``
        :param external_id: External id of the virtual portgroup
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  origin_type: :class:`str` or ``None``
        :param origin_type: Portgroup type like DistributedVirtualPortgroup
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  last_sync_time: :class:`long` or ``None``
        :param last_sync_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  resource_type: :class:`str`
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        """
        self.backing_type = backing_type
        self.key = key
        self.overall_status = overall_status
        self.cm_local_id = cm_local_id
        self.external_id = external_id
        self.origin_type = origin_type
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.last_sync_time = last_sync_time
        self.description = description
        self.display_name = display_name
        self._resource_type = resource_type
        self.tags = tags
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

DistributedVirtualPortgroup._set_binding_type(type.StructType(
    'com.vmware.nsx.model.distributed_virtual_portgroup', {
        'backing_type': type.OptionalType(type.StringType()),
        'key': type.OptionalType(type.StringType()),
        'overall_status': type.OptionalType(type.StringType()),
        'cm_local_id': type.OptionalType(type.StringType()),
        'external_id': type.OptionalType(type.StringType()),
        'origin_type': type.OptionalType(type.StringType()),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_last_sync_time': type.OptionalType(type.IntegerType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
    },
    DistributedVirtualPortgroup,
    False,
    None))



class DistributedVirtualSwitch(VapiStruct):
    """
    DistributedVirtualSwitch on a VC

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'discovered_nodes': 'discovered_nodes',
                            'lacp_group_configs': 'lacp_group_configs',
                            'origin_properties': 'origin_properties',
                            'uplink_port_names': 'uplink_port_names',
                            'uplink_portgroup': 'uplink_portgroup',
                            'uuid': 'uuid',
                            'cm_local_id': 'cm_local_id',
                            'external_id': 'external_id',
                            'origin_id': 'origin_id',
                            'origin_type': 'origin_type',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_last_sync_time': 'last_sync_time',
                            'description': 'description',
                            'display_name': 'display_name',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            }

    def __init__(self,
                 discovered_nodes=None,
                 lacp_group_configs=None,
                 origin_properties=None,
                 uplink_port_names=None,
                 uplink_portgroup=None,
                 uuid=None,
                 cm_local_id=None,
                 external_id=None,
                 origin_id=None,
                 origin_type=None,
                 links=None,
                 schema=None,
                 self_=None,
                 last_sync_time=None,
                 description=None,
                 display_name=None,
                 resource_type=None,
                 tags=None,
                ):
        """
        :type  discovered_nodes: :class:`list` of :class:`DiscoveredNode` or ``None``
        :param discovered_nodes: Array of discovered nodes connected to this switch.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  lacp_group_configs: :class:`list` of :class:`LacpGroupConfigInfo` or ``None``
        :param lacp_group_configs: It contains information about VMware specific multiple dynamic LACP
            groups.
        :type  origin_properties: :class:`list` of :class:`KeyValuePair` or ``None``
        :param origin_properties: Key-Value map of additional properties of switch
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  uplink_port_names: :class:`list` of :class:`str` or ``None``
        :param uplink_port_names: The uniform name of uplink ports on each host.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  uplink_portgroup: :class:`DistributedVirtualPortgroup` or ``None``
        :param uplink_portgroup: Uplink portgroup of distributed virtual switch
        :type  uuid: :class:`str` or ``None``
        :param uuid: UUID of the switch
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  cm_local_id: :class:`str` or ``None``
        :param cm_local_id: ID of the virtual switch in compute manager
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  external_id: :class:`str` or ``None``
        :param external_id: External id of the virtual switch
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  origin_id: :class:`str` or ``None``
        :param origin_id: ID of the compute manager where this virtual switch is discovered.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  origin_type: :class:`str` or ``None``
        :param origin_type: Switch type like VmwareDistributedVirtualSwitch
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  last_sync_time: :class:`long` or ``None``
        :param last_sync_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  resource_type: :class:`str`
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        """
        self.discovered_nodes = discovered_nodes
        self.lacp_group_configs = lacp_group_configs
        self.origin_properties = origin_properties
        self.uplink_port_names = uplink_port_names
        self.uplink_portgroup = uplink_portgroup
        self.uuid = uuid
        self.cm_local_id = cm_local_id
        self.external_id = external_id
        self.origin_id = origin_id
        self.origin_type = origin_type
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.last_sync_time = last_sync_time
        self.description = description
        self.display_name = display_name
        self._resource_type = resource_type
        self.tags = tags
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

DistributedVirtualSwitch._set_binding_type(type.StructType(
    'com.vmware.nsx.model.distributed_virtual_switch', {
        'discovered_nodes': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'DiscoveredNode'))),
        'lacp_group_configs': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'LacpGroupConfigInfo'))),
        'origin_properties': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'KeyValuePair'))),
        'uplink_port_names': type.OptionalType(type.ListType(type.StringType())),
        'uplink_portgroup': type.OptionalType(type.ReferenceType(__name__, 'DistributedVirtualPortgroup')),
        'uuid': type.OptionalType(type.StringType()),
        'cm_local_id': type.OptionalType(type.StringType()),
        'external_id': type.OptionalType(type.StringType()),
        'origin_id': type.OptionalType(type.StringType()),
        'origin_type': type.OptionalType(type.StringType()),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_last_sync_time': type.OptionalType(type.IntegerType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
    },
    DistributedVirtualSwitch,
    False,
    None))



class DnsAnswer(VapiStruct):
    """
    The response for DNS nslookup.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'answers': 'answers',
                            'authoritative_answers': 'authoritative_answers',
                            'dns_server': 'dns_server',
                            'edge_node_id': 'edge_node_id',
                            'non_authoritative_answers': 'non_authoritative_answers',
                            'raw_answer': 'raw_answer',
                            'source_ip': 'source_ip',
                            }

    def __init__(self,
                 answers=None,
                 authoritative_answers=None,
                 dns_server=None,
                 edge_node_id=None,
                 non_authoritative_answers=None,
                 raw_answer=None,
                 source_ip=None,
                ):
        """
        :type  answers: :class:`list` of :class:`DnsQueryAnswer` or ``None``
        :param answers: The answers of the query.
        :type  authoritative_answers: :class:`list` of :class:`DnsQueryAnswer` or ``None``
        :param authoritative_answers: Authotitative answers of the query. This is a deprecated property,
            please use 'answers' instead.
        :type  dns_server: :class:`str` or ``None``
        :param dns_server: Dns server ip address and port, format is \"ip address#port\".
        :type  edge_node_id: :class:`str` or ``None``
        :param edge_node_id: ID of the edge node that performed the query.
        :type  non_authoritative_answers: :class:`list` of :class:`DnsQueryAnswer` or ``None``
        :param non_authoritative_answers: Non-authotitative answers of the query. This is a deprecated
            property, please use 'answers' instead.
        :type  raw_answer: :class:`str` or ``None``
        :param raw_answer: It can be NXDOMAIN or error message which is not consisted of
            authoritative_answer or non_authoritative_answer.
        :type  source_ip: :class:`str` or ``None``
        :param source_ip: The source ip used in this lookup. format: ipv4
        """
        self.answers = answers
        self.authoritative_answers = authoritative_answers
        self.dns_server = dns_server
        self.edge_node_id = edge_node_id
        self.non_authoritative_answers = non_authoritative_answers
        self.raw_answer = raw_answer
        self.source_ip = source_ip
        VapiStruct.__init__(self)


DnsAnswer._set_binding_type(type.StructType(
    'com.vmware.nsx.model.dns_answer', {
        'answers': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'DnsQueryAnswer'))),
        'authoritative_answers': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'DnsQueryAnswer'))),
        'dns_server': type.OptionalType(type.StringType()),
        'edge_node_id': type.OptionalType(type.StringType()),
        'non_authoritative_answers': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'DnsQueryAnswer'))),
        'raw_answer': type.OptionalType(type.StringType()),
        'source_ip': type.OptionalType(type.StringType()),
    },
    DnsAnswer,
    False,
    None))



class DnsFailedQueries(VapiStruct):
    """
    The array of the failed DNS queries with entry count and timestamp on
    active and standby transport node.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'per_node_failed_queries': 'per_node_failed_queries',
                            'timestamp': 'timestamp',
                            }

    def __init__(self,
                 per_node_failed_queries=None,
                 timestamp=None,
                ):
        """
        :type  per_node_failed_queries: :class:`list` of :class:`PerNodeDnsFailedQueries` or ``None``
        :param per_node_failed_queries: The array of failed DNS queries on active and standby transport
            node. If there is no standby node, the failed queries on standby
            node will not be present.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  timestamp: :class:`str` or ``None``
        :param timestamp: Timestamp of the request, in YYYY-MM-DD HH:MM:SS.zzz format.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.per_node_failed_queries = per_node_failed_queries
        self.timestamp = timestamp
        VapiStruct.__init__(self)


DnsFailedQueries._set_binding_type(type.StructType(
    'com.vmware.nsx.model.dns_failed_queries', {
        'per_node_failed_queries': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'PerNodeDnsFailedQueries'))),
        'timestamp': type.OptionalType(type.StringType()),
    },
    DnsFailedQueries,
    False,
    None))



class DnsFailedQuery(VapiStruct):
    """
    The summary of the failed DNS query. The query result represents a full
    query chain from client VM to dns forwarder, and upstream server if no
    forwarder cache was hit.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'address': 'address',
                            'client_ip': 'client_ip',
                            'error_message': 'error_message',
                            'error_type': 'error_type',
                            'forwarder_ip': 'forwarder_ip',
                            'record_type': 'record_type',
                            'source_ip': 'source_ip',
                            'time_spent': 'time_spent',
                            'timestamp': 'timestamp',
                            'upstream_server_ip': 'upstream_server_ip',
                            }

    def __init__(self,
                 address=None,
                 client_ip=None,
                 error_message=None,
                 error_type=None,
                 forwarder_ip=None,
                 record_type=None,
                 source_ip=None,
                 time_spent=None,
                 timestamp=None,
                 upstream_server_ip=None,
                ):
        """
        :type  address: :class:`str` or ``None``
        :param address: The address be queried, can be a FQDN or an ip address.
        :type  client_ip: :class:`str` or ``None``
        :param client_ip: The client host ip address from which the query was issued.
        :type  error_message: :class:`str` or ``None``
        :param error_message: The detailed error message of the failed query, if any.
        :type  error_type: :class:`str` or ``None``
        :param error_type: The type of the query failure, e.g. NXDOMAIN, etc.
        :type  forwarder_ip: :class:`str` or ``None``
        :param forwarder_ip: The DNS forwarder ip address to which the query was first received.
        :type  record_type: :class:`str` or ``None``
        :param record_type: The record type be queried, e.g. A, CNAME, SOA, etc.
        :type  source_ip: :class:`str` or ``None``
        :param source_ip: The source ip address that is used to forward a query to an
            upstream server.
        :type  time_spent: :class:`long` or ``None``
        :param time_spent: The time the query took before it got a failed answer, in ms.
            format: int64
        :type  timestamp: :class:`str` or ``None``
        :param timestamp: Timestamp of the request, in YYYY-MM-DD HH:MM:SS.zzz format.
        :type  upstream_server_ip: :class:`str` or ``None``
        :param upstream_server_ip: The upstream server ip address to which the query was forwarded. If
            the query could not be serviced from the DNS forwarder cache, this
            property will contain the IP address of the DNS server that
            serviced the request. If the request was serviced from the cache,
            this property will be absent.
        """
        self.address = address
        self.client_ip = client_ip
        self.error_message = error_message
        self.error_type = error_type
        self.forwarder_ip = forwarder_ip
        self.record_type = record_type
        self.source_ip = source_ip
        self.time_spent = time_spent
        self.timestamp = timestamp
        self.upstream_server_ip = upstream_server_ip
        VapiStruct.__init__(self)


DnsFailedQuery._set_binding_type(type.StructType(
    'com.vmware.nsx.model.dns_failed_query', {
        'address': type.OptionalType(type.StringType()),
        'client_ip': type.OptionalType(type.StringType()),
        'error_message': type.OptionalType(type.StringType()),
        'error_type': type.OptionalType(type.StringType()),
        'forwarder_ip': type.OptionalType(type.StringType()),
        'record_type': type.OptionalType(type.StringType()),
        'source_ip': type.OptionalType(type.StringType()),
        'time_spent': type.OptionalType(type.IntegerType()),
        'timestamp': type.OptionalType(type.StringType()),
        'upstream_server_ip': type.OptionalType(type.StringType()),
    },
    DnsFailedQuery,
    False,
    None))



class DnsForwarder(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    LOG_LEVEL_DEBUG = "DEBUG"
    """


    """
    LOG_LEVEL_INFO = "INFO"
    """


    """
    LOG_LEVEL_WARNING = "WARNING"
    """


    """
    LOG_LEVEL_ERROR = "ERROR"
    """


    """
    LOG_LEVEL_FATAL = "FATAL"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'cache_size': 'cache_size',
                            'conditional_forwarders': 'conditional_forwarders',
                            'default_forwarder': 'default_forwarder',
                            'enabled': 'enabled',
                            'listener_ip': 'listener_ip',
                            'log_level': 'log_level',
                            'logical_router_id': 'logical_router_id',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 cache_size=None,
                 conditional_forwarders=None,
                 default_forwarder=None,
                 enabled=None,
                 listener_ip=None,
                 log_level=None,
                 logical_router_id=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  cache_size: :class:`long` or ``None``
        :param cache_size: One DNS answer cache entry will consume ~120 bytes. Hence 1 KB
            cache size can cache ~8 DNS answer entries, and the default 1024 KB
            cache size can hold ~8k DNS answer entries. format: int32
        :type  conditional_forwarders: :class:`list` of :class:`ConditionalForwarderZone` or ``None``
        :param conditional_forwarders: The conditional zone forwarders. During matching a zone forwarder,
            the DNS forwarder will use the conditional fowarder with the
            longest domain name that matches the query.
        :type  default_forwarder: :class:`ForwarderZone` or ``None``
        :param default_forwarder: The default zone forwarder that catches all other domain names
            except those matched by conditional forwarder zone.
        :type  enabled: :class:`bool` or ``None``
        :param enabled: Flag to enable/disable the forwarder
        :type  listener_ip: :class:`str` or ``None``
        :param listener_ip: The ip address the DNS forwarder listens on. It can be an ip
            address already owned by the logical-router uplink port or
            router-link, or a loopback port ip address. But it can not be a
            downlink port address. User needs to ensure the address is
            reachable via router or NAT from both client VMs and upstream
            servers. User will need to create Firewall rules if needed to allow
            such traffic on a Tier-1 or Tier-0. format: ipv4
        :type  log_level: :class:`str` or ``None``
        :param log_level: Possible values are: 
            
            * :attr:`DnsForwarder.LOG_LEVEL_DEBUG`
            * :attr:`DnsForwarder.LOG_LEVEL_INFO`
            * :attr:`DnsForwarder.LOG_LEVEL_WARNING`
            * :attr:`DnsForwarder.LOG_LEVEL_ERROR`
            * :attr:`DnsForwarder.LOG_LEVEL_FATAL`
            
             Log level of the DNS forwarder
        :type  logical_router_id: :class:`str` or ``None``
        :param logical_router_id: Specify the LogicalRouter where the DnsForwarder runs. The HA mode
            of the hosting LogicalRouter must be Active/Standby.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.cache_size = cache_size
        self.conditional_forwarders = conditional_forwarders
        self.default_forwarder = default_forwarder
        self.enabled = enabled
        self.listener_ip = listener_ip
        self.log_level = log_level
        self.logical_router_id = logical_router_id
        VapiStruct.__init__(self)


DnsForwarder._set_binding_type(type.StructType(
    'com.vmware.nsx.model.dns_forwarder', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'cache_size': type.OptionalType(type.IntegerType()),
        'conditional_forwarders': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ConditionalForwarderZone'))),
        'default_forwarder': type.OptionalType(type.ReferenceType(__name__, 'ForwarderZone')),
        'enabled': type.OptionalType(type.BooleanType()),
        'listener_ip': type.OptionalType(type.StringType()),
        'log_level': type.OptionalType(type.StringType()),
        'logical_router_id': type.OptionalType(type.StringType()),
    },
    DnsForwarder,
    False,
    None))



class DnsForwarderListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`DnsForwarder` or ``None``
        :param results: Paginated list of DNS forwarders
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


DnsForwarderListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.dns_forwarder_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'DnsForwarder'))),
    },
    DnsForwarderListResult,
    False,
    None))



class DnsForwarderStatistics(VapiStruct):
    """
    The current statistics counters of the DNS forwarder including cache usages
    and query numbers per forwarders.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'conditional_forwarder_statistics': 'conditional_forwarder_statistics',
                            'configured_cache_size': 'configured_cache_size',
                            'default_forwarder_statistics': 'default_forwarder_statistics',
                            'error_message': 'error_message',
                            'queries_answered_locally': 'queries_answered_locally',
                            'queries_forwarded': 'queries_forwarded',
                            'timestamp': 'timestamp',
                            'total_queries': 'total_queries',
                            'used_cache_statistics': 'used_cache_statistics',
                            }

    def __init__(self,
                 conditional_forwarder_statistics=None,
                 configured_cache_size=None,
                 default_forwarder_statistics=None,
                 error_message=None,
                 queries_answered_locally=None,
                 queries_forwarded=None,
                 timestamp=None,
                 total_queries=None,
                 used_cache_statistics=None,
                ):
        """
        :type  conditional_forwarder_statistics: :class:`list` of :class:`PerForwarderStatistics` or ``None``
        :param conditional_forwarder_statistics: The statistics of conditional forwarders
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  configured_cache_size: :class:`long` or ``None``
        :param configured_cache_size: The configured cache size, in kb format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  default_forwarder_statistics: :class:`PerForwarderStatistics` or ``None``
        :param default_forwarder_statistics: The statistics of default forwarder
        :type  error_message: :class:`str` or ``None``
        :param error_message: Error message, if available
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  queries_answered_locally: :class:`long` or ``None``
        :param queries_answered_locally: The totocal number of queries answered from local cache format:
            int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  queries_forwarded: :class:`long` or ``None``
        :param queries_forwarded: The total number of forwarded dns queries format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  timestamp: :class:`long` or ``None``
        :param timestamp: Time stamp of the current statistics, in ms format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  total_queries: :class:`long` or ``None``
        :param total_queries: The total number of received dns queries format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  used_cache_statistics: :class:`list` of :class:`PerNodeUsedCacheStatistics` or ``None``
        :param used_cache_statistics: The statistics of used cache
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.conditional_forwarder_statistics = conditional_forwarder_statistics
        self.configured_cache_size = configured_cache_size
        self.default_forwarder_statistics = default_forwarder_statistics
        self.error_message = error_message
        self.queries_answered_locally = queries_answered_locally
        self.queries_forwarded = queries_forwarded
        self.timestamp = timestamp
        self.total_queries = total_queries
        self.used_cache_statistics = used_cache_statistics
        VapiStruct.__init__(self)


DnsForwarderStatistics._set_binding_type(type.StructType(
    'com.vmware.nsx.model.dns_forwarder_statistics', {
        'conditional_forwarder_statistics': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'PerForwarderStatistics'))),
        'configured_cache_size': type.OptionalType(type.IntegerType()),
        'default_forwarder_statistics': type.OptionalType(type.ReferenceType(__name__, 'PerForwarderStatistics')),
        'error_message': type.OptionalType(type.StringType()),
        'queries_answered_locally': type.OptionalType(type.IntegerType()),
        'queries_forwarded': type.OptionalType(type.IntegerType()),
        'timestamp': type.OptionalType(type.IntegerType()),
        'total_queries': type.OptionalType(type.IntegerType()),
        'used_cache_statistics': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'PerNodeUsedCacheStatistics'))),
    },
    DnsForwarderStatistics,
    False,
    None))



class DnsForwarderStatus(VapiStruct):
    """
    The current runtime status of the DNS forwarder including the hosting
    transport nodes and forwarder service status.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATUS_UP = "UP"
    """


    """
    STATUS_DOWN = "DOWN"
    """


    """
    STATUS_ERROR = "ERROR"
    """


    """
    STATUS_NO_BACKUP = "NO_BACKUP"
    """


    """



    _canonical_to_pep_names = {
                            'active_node': 'active_node',
                            'extra_message': 'extra_message',
                            'standby_node': 'standby_node',
                            'status': 'status',
                            'timestamp': 'timestamp',
                            }

    def __init__(self,
                 active_node=None,
                 extra_message=None,
                 standby_node=None,
                 status=None,
                 timestamp=None,
                ):
        """
        :type  active_node: :class:`str` or ``None``
        :param active_node: Uuid of active transport node
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  extra_message: :class:`str` or ``None``
        :param extra_message: Extra message, if available
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  standby_node: :class:`str` or ``None``
        :param standby_node: Uuid of stand_by transport node. null if non-HA mode
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  status: :class:`str` or ``None``
        :param status: Possible values are: 
            
            * :attr:`DnsForwarderStatus.STATUS_UP`
            * :attr:`DnsForwarderStatus.STATUS_DOWN`
            * :attr:`DnsForwarderStatus.STATUS_ERROR`
            * :attr:`DnsForwarderStatus.STATUS_NO_BACKUP`
            
            UP means the DNS forwarder is working correctly on the active
            transport node and the stand-by transport node (if present).
            Failover will occur if either node goes down. DOWN means the DNS
            forwarder is down on both active transport node and standby node
            (if present). The DNS forwarder does not function in this
            situation. Error means there is some error on one or both transport
            node, or no status was reported from one or both transport nodes.
            The dns forwarder may be working (or not working). NO_BACKUP means
            dns forwarder is working in only one transport node, either because
            it is down on the standby node, or no standby is configured. An
            forwarder outage will occur if the active node goes down.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  timestamp: :class:`long` or ``None``
        :param timestamp: Time stamp of the current status, in ms format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.active_node = active_node
        self.extra_message = extra_message
        self.standby_node = standby_node
        self.status = status
        self.timestamp = timestamp
        VapiStruct.__init__(self)


DnsForwarderStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.dns_forwarder_status', {
        'active_node': type.OptionalType(type.StringType()),
        'extra_message': type.OptionalType(type.StringType()),
        'standby_node': type.OptionalType(type.StringType()),
        'status': type.OptionalType(type.StringType()),
        'timestamp': type.OptionalType(type.IntegerType()),
    },
    DnsForwarderStatus,
    False,
    None))



class DnsHeader(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    ADDRESS_TYPE_V4 = "V4"
    """


    """
    ADDRESS_TYPE_V6 = "V6"
    """


    """
    MESSAGE_TYPE_QUERY = "QUERY"
    """


    """
    MESSAGE_TYPE_RESPONSE = "RESPONSE"
    """


    """



    _canonical_to_pep_names = {
                            'address': 'address',
                            'address_type': 'address_type',
                            'message_type': 'message_type',
                            }

    def __init__(self,
                 address=None,
                 address_type=None,
                 message_type=None,
                ):
        """
        :type  address: :class:`str` or ``None``
        :param address: This is used to define what is being asked or responded. format:
            hostname-or-ip
        :type  address_type: :class:`str` or ``None``
        :param address_type: Possible values are: 
            
            * :attr:`DnsHeader.ADDRESS_TYPE_V4`
            * :attr:`DnsHeader.ADDRESS_TYPE_V6`
            
            This is used to specify the type of the address. V4 - The address
            provided is an IPv4 domain name/IP address, the Type in query or
            response will be A V6 - The address provided is an IPv6 domain
            name/IP address, the Type in query or response will be AAAA
        :type  message_type: :class:`str` or ``None``
        :param message_type: Possible values are: 
            
            * :attr:`DnsHeader.MESSAGE_TYPE_QUERY`
            * :attr:`DnsHeader.MESSAGE_TYPE_RESPONSE`
            
             Specifies the message type whether it is a query or a response.
        """
        self.address = address
        self.address_type = address_type
        self.message_type = message_type
        VapiStruct.__init__(self)


DnsHeader._set_binding_type(type.StructType(
    'com.vmware.nsx.model.dns_header', {
        'address': type.OptionalType(type.StringType()),
        'address_type': type.OptionalType(type.StringType()),
        'message_type': type.OptionalType(type.StringType()),
    },
    DnsHeader,
    False,
    None))



class DnsQueryAnswer(VapiStruct):
    """
    Answer of nslookup

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'address': 'address',
                            'name': 'name',
                            'raw_string': 'raw_string',
                            }

    def __init__(self,
                 address=None,
                 name=None,
                 raw_string=None,
                ):
        """
        :type  address: :class:`str` or ``None``
        :param address: Can be resolved ip address.
        :type  name: :class:`str` or ``None``
        :param name: Matched name of the given address.
        :type  raw_string: :class:`str` or ``None``
        :param raw_string: Unparsed answer string from raw_answer.
        """
        self.address = address
        self.name = name
        self.raw_string = raw_string
        VapiStruct.__init__(self)


DnsQueryAnswer._set_binding_type(type.StructType(
    'com.vmware.nsx.model.dns_query_answer', {
        'address': type.OptionalType(type.StringType()),
        'name': type.OptionalType(type.StringType()),
        'raw_string': type.OptionalType(type.StringType()),
    },
    DnsQueryAnswer,
    False,
    None))



class DnsTtlConfig(VapiStruct):
    """
    Firewall to use TTL config to manage firewall cache to expire snooped FQDN
    entries from DNS response.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    DNS_TTL_TYPE_USE_TTL = "USE_TTL"
    """


    """
    DNS_TTL_TYPE_AUTO = "AUTO"
    """


    """
    DNS_TTL_TYPE_NEVER_EXPIRE = "NEVER_EXPIRE"
    """


    """



    _canonical_to_pep_names = {
                            'dns_ttl_type': 'dns_ttl_type',
                            'ttl': 'ttl',
                            }

    def __init__(self,
                 dns_ttl_type=None,
                 ttl=None,
                ):
        """
        :type  dns_ttl_type: :class:`str` or ``None``
        :param dns_ttl_type: Possible values are: 
            
            * :attr:`DnsTtlConfig.DNS_TTL_TYPE_USE_TTL`
            * :attr:`DnsTtlConfig.DNS_TTL_TYPE_AUTO`
            * :attr:`DnsTtlConfig.DNS_TTL_TYPE_NEVER_EXPIRE`
            
             TTL type to decide how to manage ttl.
        :type  ttl: :class:`long` or ``None``
        :param ttl: The number of seconds that snooped DNS responses are retained in
            the cache. Used only when dns_ttl_type is USE_TTL. format: int64
        """
        self.dns_ttl_type = dns_ttl_type
        self.ttl = ttl
        VapiStruct.__init__(self)


DnsTtlConfig._set_binding_type(type.StructType(
    'com.vmware.nsx.model.dns_ttl_config', {
        'dns_ttl_type': type.OptionalType(type.StringType()),
        'ttl': type.OptionalType(type.IntegerType()),
    },
    DnsTtlConfig,
    False,
    None))



class DonutConfiguration(VapiStruct):
    """
    Represents configuration of a Donut

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "DonutConfiguration"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'count': 'count',
                            'display_count': 'display_count',
                            'label': 'label',
                            'navigation': 'navigation',
                            'sections': 'sections',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'datasources': 'datasources',
                            'default_filter_value': 'default_filter_value',
                            'drilldown_id': 'drilldown_id',
                            'filter': 'filter',
                            'filter_value_required': 'filter_value_required',
                            'footer': 'footer',
                            'icons': 'icons',
                            'is_drilldown': 'is_drilldown',
                            'legend': 'legend',
                            'shared': 'shared',
                            'span': 'span',
                            'weight': 'weight',
                            }

    def __init__(self,
                 count=None,
                 display_count=None,
                 label=None,
                 navigation=None,
                 sections=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='DonutConfiguration',
                 tags=None,
                 datasources=None,
                 default_filter_value=None,
                 drilldown_id=None,
                 filter=None,
                 filter_value_required=None,
                 footer=None,
                 icons=None,
                 is_drilldown=None,
                 legend=None,
                 shared=None,
                 span=None,
                 weight=None,
                ):
        """
        :type  count: :class:`str` or ``None``
        :param count: Expression to retrieve count to be shown on Donut.
        :type  display_count: :class:`bool` or ``None``
        :param display_count: If true, displays the count of entities in the donut
        :type  label: :class:`Label` or ``None``
        :param label: Displayed at the middle of the donut, by default. It labels the
            entities of donut.
        :type  navigation: :class:`str` or ``None``
        :param navigation: Hyperlink of the specified UI page that provides details.
        :type  sections: :class:`list` of :class:`DonutSection` or ``None``
        :param sections: Sections
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Title of the widget. If display_name is omitted, the widget will be
            shown without a title.
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_LABELVALUECONFIGURATION`
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_DONUTCONFIGURATION`
            *
              :attr:`WidgetConfiguration.RESOURCE_TYPE_MULTIWIDGETCONFIGURATION`
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_CONTAINERCONFIGURATION`
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_STATSCONFIGURATION`
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_GRIDCONFIGURATION`
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_GRAPHCONFIGURATION`
            *
              :attr:`WidgetConfiguration.RESOURCE_TYPE_CUSTOMWIDGETCONFIGURATION`
            *
              :attr:`WidgetConfiguration.RESOURCE_TYPE_DROPDOWNFILTERWIDGETCONFIGURATION`
            
            Supported visualization types are LabelValueConfiguration,
            DonutConfiguration, GridConfiguration, StatsConfiguration,
            MultiWidgetConfiguration, GraphConfiguration,
            ContainerConfiguration, CustomWidgetConfiguration and
            DropdownFilterWidgetConfiguration.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  datasources: :class:`list` of :class:`Datasource` or ``None``
        :param datasources: The 'datasources' represent the sources from which data will be
            fetched. Currently, only NSX-API is supported as a 'default'
            datasource. An example of specifying 'default' datasource along
            with the urls to fetch data from is given at 'example_request'
            section of 'CreateWidgetConfiguration' API.
        :type  default_filter_value: :class:`list` of :class:`DefaultFilterValue` or ``None``
        :param default_filter_value: Default filter values to be passed to datasources. This will be
            used when the report is requested without filter values.
        :type  drilldown_id: :class:`str` or ``None``
        :param drilldown_id: Id of drilldown widget, if any. Id should be a valid id of an
            existing widget. A widget is considered as drilldown widget when it
            is associated with any other widget and provides more detailed
            information about any data item from the parent widget.
        :type  filter: :class:`str` or ``None``
        :param filter: Id of filter widget for subscription, if any. Id should be a valid
            id of an existing filter widget. Filter widget should be from the
            same view. Datasource URLs should have placeholder values equal to
            filter alias to accept the filter value on filter change.
        :type  filter_value_required: :class:`bool` or ``None``
        :param filter_value_required: Flag to indicate that widget will continue to work without filter
            value. If this flag is set to false then default_filter_value is
            manadatory.
        :type  footer: :class:`Footer` or ``None``
        :param footer: 
        :type  icons: :class:`list` of :class:`Icon` or ``None``
        :param icons: Icons to be applied at dashboard for widgets and UI elements.
        :type  is_drilldown: :class:`bool` or ``None``
        :param is_drilldown: Set to true if this widget should be used as a drilldown.
        :type  legend: :class:`Legend` or ``None``
        :param legend: Legend to be displayed. If legend is not needed, do not include it.
        :type  shared: :class:`bool` or ``None``
        :param shared: Please use the property 'shared' of View instead of this. The
            widgets of a shared view are visible to other users.
        :type  span: :class:`long` or ``None``
        :param span: Represents the horizontal span of the widget / container. format:
            int32
        :type  weight: :class:`long` or ``None``
        :param weight: Specify relavite weight in WidgetItem for placement in a view.
            Please see WidgetItem for details. format: int32
        """
        self.count = count
        self.display_count = display_count
        self.label = label
        self.navigation = navigation
        self.sections = sections
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        self.datasources = datasources
        self.default_filter_value = default_filter_value
        self.drilldown_id = drilldown_id
        self.filter = filter
        self.filter_value_required = filter_value_required
        self.footer = footer
        self.icons = icons
        self.is_drilldown = is_drilldown
        self.legend = legend
        self.shared = shared
        self.span = span
        self.weight = weight
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

DonutConfiguration._set_binding_type(type.StructType(
    'com.vmware.nsx.model.donut_configuration', {
        'count': type.OptionalType(type.StringType()),
        'display_count': type.OptionalType(type.BooleanType()),
        'label': type.OptionalType(type.ReferenceType(__name__, 'Label')),
        'navigation': type.OptionalType(type.StringType()),
        'sections': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'DonutSection'))),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'datasources': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Datasource'))),
        'default_filter_value': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'DefaultFilterValue'))),
        'drilldown_id': type.OptionalType(type.StringType()),
        'filter': type.OptionalType(type.StringType()),
        'filter_value_required': type.OptionalType(type.BooleanType()),
        'footer': type.OptionalType(type.ReferenceType(__name__, 'Footer')),
        'icons': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Icon'))),
        'is_drilldown': type.OptionalType(type.BooleanType()),
        'legend': type.OptionalType(type.ReferenceType(__name__, 'Legend')),
        'shared': type.OptionalType(type.BooleanType()),
        'span': type.OptionalType(type.IntegerType()),
        'weight': type.OptionalType(type.IntegerType()),
    },
    DonutConfiguration,
    False,
    None))



class DonutPart(VapiStruct):
    """
    Represents an entity or portion to be plotted on a donut or stats chart.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'condition': 'condition',
                            'drilldown_id': 'drilldown_id',
                            'field': 'field',
                            'hide_empty_legend': 'hide_empty_legend',
                            'label': 'label',
                            'navigation': 'navigation',
                            'render_configuration': 'render_configuration',
                            'tooltip': 'tooltip',
                            }

    def __init__(self,
                 condition=None,
                 drilldown_id=None,
                 field=None,
                 hide_empty_legend=None,
                 label=None,
                 navigation=None,
                 render_configuration=None,
                 tooltip=None,
                ):
        """
        :type  condition: :class:`str` or ``None``
        :param condition: If the condition is met then the part will be displayed. Examples
            of expression syntax are provided under 'example_request' section
            of 'CreateWidgetConfiguration' API.
        :type  drilldown_id: :class:`str` or ``None``
        :param drilldown_id: Id of drilldown widget, if any. Id should be a valid id of an
            existing widget. A widget is considered as drilldown widget when it
            is associated with any other widget and provides more detailed
            information about any data item from the parent widget.
        :type  field: :class:`str` or ``None``
        :param field: A numerical value that represents the portion or entity of the
            donut or stats chart.
        :type  hide_empty_legend: :class:`bool` or ``None``
        :param hide_empty_legend: If true, legend will be shown only if the data for the part is
            available. This is applicable only if legends are specified in
            widget configuration.
        :type  label: :class:`Label` or ``None``
        :param label: If a section 'template' holds this donut or stats part, then the
            label is auto-generated from the fetched field values after
            applying the template.
        :type  navigation: :class:`str` or ``None``
        :param navigation: Hyperlink of the specified UI page that provides details. If
            drilldown_id is provided, then navigation cannot be used.
        :type  render_configuration: :class:`list` of :class:`RenderConfiguration` or ``None``
        :param render_configuration: Additional rendering or conditional evaluation of the field values
            to be performed, if any.
        :type  tooltip: :class:`list` of :class:`Tooltip` or ``None``
        :param tooltip: Multi-line text to be shown on tooltip while hovering over the
            portion.
        """
        self.condition = condition
        self.drilldown_id = drilldown_id
        self.field = field
        self.hide_empty_legend = hide_empty_legend
        self.label = label
        self.navigation = navigation
        self.render_configuration = render_configuration
        self.tooltip = tooltip
        VapiStruct.__init__(self)


DonutPart._set_binding_type(type.StructType(
    'com.vmware.nsx.model.donut_part', {
        'condition': type.OptionalType(type.StringType()),
        'drilldown_id': type.OptionalType(type.StringType()),
        'field': type.OptionalType(type.StringType()),
        'hide_empty_legend': type.OptionalType(type.BooleanType()),
        'label': type.OptionalType(type.ReferenceType(__name__, 'Label')),
        'navigation': type.OptionalType(type.StringType()),
        'render_configuration': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'RenderConfiguration'))),
        'tooltip': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tooltip'))),
    },
    DonutPart,
    False,
    None))



class DonutSection(VapiStruct):
    """
    Represents high level logical grouping of portions or segments of a donut /
    stats chart.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'parts': 'parts',
                            'row_list_field': 'row_list_field',
                            'template': 'template',
                            }

    def __init__(self,
                 parts=None,
                 row_list_field=None,
                 template=None,
                ):
        """
        :type  parts: :class:`list` of :class:`DonutPart` or ``None``
        :param parts: Array of portions or parts of the donut or stats chart.
        :type  row_list_field: :class:`str` or ``None``
        :param row_list_field: Field of the root of the api result set for forming parts.
        :type  template: :class:`bool` or ``None``
        :param template: If true, the section will be appled as template for forming parts.
            Only one part will be formed from each element of 'row_list_field'.
        """
        self.parts = parts
        self.row_list_field = row_list_field
        self.template = template
        VapiStruct.__init__(self)


DonutSection._set_binding_type(type.StructType(
    'com.vmware.nsx.model.donut_section', {
        'parts': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'DonutPart'))),
        'row_list_field': type.OptionalType(type.StringType()),
        'template': type.OptionalType(type.BooleanType()),
    },
    DonutSection,
    False,
    None))



class DropdownFilterWidgetConfiguration(VapiStruct):
    """
    Represents configuration for dropdown filter widget.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'default_value': 'default_value',
                            'dropdown_item': 'dropdown_item',
                            'placeholder_msg': 'placeholder_msg',
                            'static_filter_condition': 'static_filter_condition',
                            'static_filters': 'static_filters',
                            'alias': 'alias',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'datasources': 'datasources',
                            'default_filter_value': 'default_filter_value',
                            'drilldown_id': 'drilldown_id',
                            'filter': 'filter',
                            'filter_value_required': 'filter_value_required',
                            'footer': 'footer',
                            'icons': 'icons',
                            'is_drilldown': 'is_drilldown',
                            'legend': 'legend',
                            'shared': 'shared',
                            'span': 'span',
                            'weight': 'weight',
                            }

    def __init__(self,
                 default_value=None,
                 dropdown_item=None,
                 placeholder_msg=None,
                 static_filter_condition=None,
                 static_filters=None,
                 alias=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 datasources=None,
                 default_filter_value=None,
                 drilldown_id=None,
                 filter=None,
                 filter_value_required=None,
                 footer=None,
                 icons=None,
                 is_drilldown=None,
                 legend=None,
                 shared=None,
                 span=None,
                 weight=None,
                ):
        """
        :type  default_value: :class:`str` or ``None``
        :param default_value: Expression to specify default value of filter.
        :type  dropdown_item: :class:`DropdownItem` or ``None``
        :param dropdown_item: Defines the item of a dropdown.
        :type  placeholder_msg: :class:`str` or ``None``
        :param placeholder_msg: Placeholder message to be displayed in dropdown filter.
        :type  static_filter_condition: :class:`str` or ``None``
        :param static_filter_condition: If the condition is met then the static filter will be added. If no
            condition is provided, then the static filters will be applied
            unconditionally.
        :type  static_filters: :class:`list` of :class:`StaticFilter` or ``None``
        :param static_filters: Additional static items to be added in dropdown filter. Example can
            be 'ALL'.
        :type  alias: :class:`str` or ``None``
        :param alias: Alias to be used when emitting filter value.
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Title of the widget. If display_name is omitted, the widget will be
            shown without a title.
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_LABELVALUECONFIGURATION`
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_DONUTCONFIGURATION`
            *
              :attr:`WidgetConfiguration.RESOURCE_TYPE_MULTIWIDGETCONFIGURATION`
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_CONTAINERCONFIGURATION`
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_STATSCONFIGURATION`
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_GRIDCONFIGURATION`
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_GRAPHCONFIGURATION`
            *
              :attr:`WidgetConfiguration.RESOURCE_TYPE_CUSTOMWIDGETCONFIGURATION`
            *
              :attr:`WidgetConfiguration.RESOURCE_TYPE_DROPDOWNFILTERWIDGETCONFIGURATION`
            
            Supported visualization types are LabelValueConfiguration,
            DonutConfiguration, GridConfiguration, StatsConfiguration,
            MultiWidgetConfiguration, GraphConfiguration,
            ContainerConfiguration, CustomWidgetConfiguration and
            DropdownFilterWidgetConfiguration.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  datasources: :class:`list` of :class:`Datasource` or ``None``
        :param datasources: The 'datasources' represent the sources from which data will be
            fetched. Currently, only NSX-API is supported as a 'default'
            datasource. An example of specifying 'default' datasource along
            with the urls to fetch data from is given at 'example_request'
            section of 'CreateWidgetConfiguration' API.
        :type  default_filter_value: :class:`list` of :class:`DefaultFilterValue` or ``None``
        :param default_filter_value: Default filter values to be passed to datasources. This will be
            used when the report is requested without filter values.
        :type  drilldown_id: :class:`str` or ``None``
        :param drilldown_id: Id of drilldown widget, if any. Id should be a valid id of an
            existing widget. A widget is considered as drilldown widget when it
            is associated with any other widget and provides more detailed
            information about any data item from the parent widget.
        :type  filter: :class:`str` or ``None``
        :param filter: Id of filter widget for subscription, if any. Id should be a valid
            id of an existing filter widget. Filter widget should be from the
            same view. Datasource URLs should have placeholder values equal to
            filter alias to accept the filter value on filter change.
        :type  filter_value_required: :class:`bool` or ``None``
        :param filter_value_required: Flag to indicate that widget will continue to work without filter
            value. If this flag is set to false then default_filter_value is
            manadatory.
        :type  footer: :class:`Footer` or ``None``
        :param footer: 
        :type  icons: :class:`list` of :class:`Icon` or ``None``
        :param icons: Icons to be applied at dashboard for widgets and UI elements.
        :type  is_drilldown: :class:`bool` or ``None``
        :param is_drilldown: Set to true if this widget should be used as a drilldown.
        :type  legend: :class:`Legend` or ``None``
        :param legend: Legend to be displayed. If legend is not needed, do not include it.
        :type  shared: :class:`bool` or ``None``
        :param shared: Please use the property 'shared' of View instead of this. The
            widgets of a shared view are visible to other users.
        :type  span: :class:`long` or ``None``
        :param span: Represents the horizontal span of the widget / container. format:
            int32
        :type  weight: :class:`long` or ``None``
        :param weight: Specify relavite weight in WidgetItem for placement in a view.
            Please see WidgetItem for details. format: int32
        """
        self.default_value = default_value
        self.dropdown_item = dropdown_item
        self.placeholder_msg = placeholder_msg
        self.static_filter_condition = static_filter_condition
        self.static_filters = static_filters
        self.alias = alias
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        self.datasources = datasources
        self.default_filter_value = default_filter_value
        self.drilldown_id = drilldown_id
        self.filter = filter
        self.filter_value_required = filter_value_required
        self.footer = footer
        self.icons = icons
        self.is_drilldown = is_drilldown
        self.legend = legend
        self.shared = shared
        self.span = span
        self.weight = weight
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

DropdownFilterWidgetConfiguration._set_binding_type(type.StructType(
    'com.vmware.nsx.model.dropdown_filter_widget_configuration', {
        'default_value': type.OptionalType(type.StringType()),
        'dropdown_item': type.OptionalType(type.ReferenceType(__name__, 'DropdownItem')),
        'placeholder_msg': type.OptionalType(type.StringType()),
        'static_filter_condition': type.OptionalType(type.StringType()),
        'static_filters': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'StaticFilter'))),
        'alias': type.OptionalType(type.StringType()),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'datasources': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Datasource'))),
        'default_filter_value': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'DefaultFilterValue'))),
        'drilldown_id': type.OptionalType(type.StringType()),
        'filter': type.OptionalType(type.StringType()),
        'filter_value_required': type.OptionalType(type.BooleanType()),
        'footer': type.OptionalType(type.ReferenceType(__name__, 'Footer')),
        'icons': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Icon'))),
        'is_drilldown': type.OptionalType(type.BooleanType()),
        'legend': type.OptionalType(type.ReferenceType(__name__, 'Legend')),
        'shared': type.OptionalType(type.BooleanType()),
        'span': type.OptionalType(type.IntegerType()),
        'weight': type.OptionalType(type.IntegerType()),
    },
    DropdownFilterWidgetConfiguration,
    False,
    None))



class DropdownItem(VapiStruct):
    """
    Dropdown item definition

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'display_name': 'display_name',
                            'field': 'field',
                            'value': 'value',
                            }

    def __init__(self,
                 display_name=None,
                 field=None,
                 value=None,
                ):
        """
        :type  display_name: :class:`str` or ``None``
        :param display_name: expression to extract display name to be shown in the drop down.
        :type  field: :class:`str` or ``None``
        :param field: An expression that represents the items of the dropdown filter.
        :type  value: :class:`str` or ``None``
        :param value: Value of filter inside dropdown filter.
        """
        self.display_name = display_name
        self.field = field
        self.value = value
        VapiStruct.__init__(self)


DropdownItem._set_binding_type(type.StructType(
    'com.vmware.nsx.model.dropdown_item', {
        'display_name': type.OptionalType(type.StringType()),
        'field': type.OptionalType(type.StringType()),
        'value': type.OptionalType(type.StringType()),
    },
    DropdownItem,
    False,
    None))



class Dscp(VapiStruct):
    """
    Dscp value is ignored in case of 'TRUSTED' DscpMode.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    MODE_TRUSTED = "TRUSTED"
    """


    """
    MODE_UNTRUSTED = "UNTRUSTED"
    """


    """



    _canonical_to_pep_names = {
                            'mode': 'mode',
                            'priority': 'priority',
                            }

    def __init__(self,
                 mode=None,
                 priority=None,
                ):
        """
        :type  mode: :class:`str` or ``None``
        :param mode: Possible values are: 
            
            * :attr:`Dscp.MODE_TRUSTED`
            * :attr:`Dscp.MODE_UNTRUSTED`
            
             Trust settings
        :type  priority: :class:`long` or ``None``
        :param priority: Internal Forwarding Priority format: int32
        """
        self.mode = mode
        self.priority = priority
        VapiStruct.__init__(self)


Dscp._set_binding_type(type.StructType(
    'com.vmware.nsx.model.dscp', {
        'mode': type.OptionalType(type.StringType()),
        'priority': type.OptionalType(type.IntegerType()),
    },
    Dscp,
    False,
    None))



class DuplicateAddressBindingEntry(VapiStruct):
    """
    Duplicate address binding information

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    SOURCE_INVALID = "INVALID"
    """


    """
    SOURCE_UNKNOWN = "UNKNOWN"
    """


    """
    SOURCE_USER_DEFINED = "USER_DEFINED"
    """


    """
    SOURCE_ARP_SNOOPING = "ARP_SNOOPING"
    """


    """
    SOURCE_DHCP_SNOOPING = "DHCP_SNOOPING"
    """


    """
    SOURCE_VM_TOOLS = "VM_TOOLS"
    """


    """
    SOURCE_ND_SNOOPING = "ND_SNOOPING"
    """


    """
    SOURCE_DHCPV6_SNOOPING = "DHCPV6_SNOOPING"
    """


    """
    SOURCE_VM_TOOLS_V6 = "VM_TOOLS_V6"
    """


    """



    _canonical_to_pep_names = {
                            'binding': 'binding',
                            'binding_timestamp': 'binding_timestamp',
                            'source': 'source',
                            'conflicting_port': 'conflicting_port',
                            }

    def __init__(self,
                 binding=None,
                 binding_timestamp=None,
                 source=None,
                 conflicting_port=None,
                ):
        """
        :type  binding: :class:`PacketAddressClassifier` or ``None``
        :param binding: Combination of IP-MAC-VLAN binding
        :type  binding_timestamp: :class:`long` or ``None``
        :param binding_timestamp: Timestamp at which the binding was discovered via snooping or
            manually specified by the user format: int64
        :type  source: :class:`str` or ``None``
        :param source: Possible values are: 
            
            * :attr:`DuplicateAddressBindingEntry.SOURCE_INVALID`
            * :attr:`DuplicateAddressBindingEntry.SOURCE_UNKNOWN`
            * :attr:`DuplicateAddressBindingEntry.SOURCE_USER_DEFINED`
            * :attr:`DuplicateAddressBindingEntry.SOURCE_ARP_SNOOPING`
            * :attr:`DuplicateAddressBindingEntry.SOURCE_DHCP_SNOOPING`
            * :attr:`DuplicateAddressBindingEntry.SOURCE_VM_TOOLS`
            * :attr:`DuplicateAddressBindingEntry.SOURCE_ND_SNOOPING`
            * :attr:`DuplicateAddressBindingEntry.SOURCE_DHCPV6_SNOOPING`
            * :attr:`DuplicateAddressBindingEntry.SOURCE_VM_TOOLS_V6`
            
             Source from which the address binding entry was obtained
        :type  conflicting_port: :class:`str` or ``None``
        :param conflicting_port: Provides the ID of the port on which the same address bidning
            exists
        """
        self.binding = binding
        self.binding_timestamp = binding_timestamp
        self.source = source
        self.conflicting_port = conflicting_port
        VapiStruct.__init__(self)


DuplicateAddressBindingEntry._set_binding_type(type.StructType(
    'com.vmware.nsx.model.duplicate_address_binding_entry', {
        'binding': type.OptionalType(type.ReferenceType(__name__, 'PacketAddressClassifier')),
        'binding_timestamp': type.OptionalType(type.IntegerType()),
        'source': type.OptionalType(type.StringType()),
        'conflicting_port': type.OptionalType(type.StringType()),
    },
    DuplicateAddressBindingEntry,
    False,
    None))



class DuplicateIPDetection(VapiStruct):
    """
    Duplicate IP detection and control

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'duplicate_ip_detection_enabled': 'duplicate_ip_detection_enabled',
                            }

    def __init__(self,
                 duplicate_ip_detection_enabled=None,
                ):
        """
        :type  duplicate_ip_detection_enabled: :class:`bool` or ``None``
        :param duplicate_ip_detection_enabled: Indicates whether duplicate IP detection should be enabled
        """
        self.duplicate_ip_detection_enabled = duplicate_ip_detection_enabled
        VapiStruct.__init__(self)


DuplicateIPDetection._set_binding_type(type.StructType(
    'com.vmware.nsx.model.duplicate_IP_detection', {
        'duplicate_ip_detection_enabled': type.OptionalType(type.BooleanType()),
    },
    DuplicateIPDetection,
    False,
    None))



class EULAAcceptance(VapiStruct):
    """
    Indicate the status of End User License Agreement acceptance

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'acceptance': 'acceptance',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 acceptance=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  acceptance: :class:`bool` or ``None``
        :param acceptance: Acceptance status of End User License Agreement
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.acceptance = acceptance
        VapiStruct.__init__(self)


EULAAcceptance._set_binding_type(type.StructType(
    'com.vmware.nsx.model.EULA_acceptance', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'acceptance': type.OptionalType(type.BooleanType()),
    },
    EULAAcceptance,
    False,
    None))



class EULAContent(VapiStruct):
    """
    End User License Agreement content

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'content': 'content',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 content=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  content: :class:`str` or ``None``
        :param content: Content of End User License Agreement
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.content = content
        VapiStruct.__init__(self)


EULAContent._set_binding_type(type.StructType(
    'com.vmware.nsx.model.EULA_content', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'content': type.OptionalType(type.StringType()),
    },
    EULAContent,
    False,
    None))



class EdgeCluster(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    DEPLOYMENT_TYPE_VIRTUAL_MACHINE = "VIRTUAL_MACHINE"
    """


    """
    DEPLOYMENT_TYPE_PHYSICAL_MACHINE = "PHYSICAL_MACHINE"
    """


    """
    DEPLOYMENT_TYPE_UNKNOWN = "UNKNOWN"
    """


    """
    MEMBER_NODE_TYPE_EDGE_NODE = "EDGE_NODE"
    """


    """
    MEMBER_NODE_TYPE_PUBLIC_CLOUD_GATEWAY_NODE = "PUBLIC_CLOUD_GATEWAY_NODE"
    """


    """
    MEMBER_NODE_TYPE_UNKNOWN = "UNKNOWN"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'allocation_rules': 'allocation_rules',
                            'cluster_profile_bindings': 'cluster_profile_bindings',
                            'deployment_type': 'deployment_type',
                            'enable_inter_site_forwarding': 'enable_inter_site_forwarding',
                            'member_node_type': 'member_node_type',
                            'members': 'members',
                            'node_rtep_ips': 'node_rtep_ips',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 allocation_rules=None,
                 cluster_profile_bindings=None,
                 deployment_type=None,
                 enable_inter_site_forwarding=None,
                 member_node_type=None,
                 members=None,
                 node_rtep_ips=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  allocation_rules: :class:`list` of :class:`AllocationRule` or ``None``
        :param allocation_rules: Set of allocation rules and respected action for auto placement of
            logical router, DHCP and MDProxy on edge cluster members.
        :type  cluster_profile_bindings: :class:`list` of :class:`ClusterProfileTypeIdEntry` or ``None``
        :param cluster_profile_bindings: Edge cluster profile bindings
        :type  deployment_type: :class:`str` or ``None``
        :param deployment_type: Possible values are: 
            
            * :attr:`EdgeCluster.DEPLOYMENT_TYPE_VIRTUAL_MACHINE`
            * :attr:`EdgeCluster.DEPLOYMENT_TYPE_PHYSICAL_MACHINE`
            * :attr:`EdgeCluster.DEPLOYMENT_TYPE_UNKNOWN`
            
            This field is a readonly field which shows the deployment_type of
            members. It returns UNKNOWN if there are no members, and returns
            VIRTUAL_MACHINE| PHYSICAL_MACHINE if all edge members are
            VIRTUAL_MACHINE|PHYSICAL_MACHINE. It returns HYBRID if the cluster
            contains edge members of both types VIRTUAL_MACHINE and
            PHYSICAL_MACHINE.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  enable_inter_site_forwarding: :class:`bool` or ``None``
        :param enable_inter_site_forwarding: Flag should be only use in federation for inter site l2 and l3
            forwarding. Before enabling this flag, all the edge cluster members
            must have remote tunnel endpoint configured. TIER0/TIER1 logical
            routers managed by GM must be associated with edge cluster which
            has inter-site forwarding enabled.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  member_node_type: :class:`str` or ``None``
        :param member_node_type: Possible values are: 
            
            * :attr:`EdgeCluster.MEMBER_NODE_TYPE_EDGE_NODE`
            * :attr:`EdgeCluster.MEMBER_NODE_TYPE_PUBLIC_CLOUD_GATEWAY_NODE`
            * :attr:`EdgeCluster.MEMBER_NODE_TYPE_UNKNOWN`
            
            Edge cluster is homogenous collection of transport nodes. Hence all
            transport nodes of the cluster must be of same type. This readonly
            field shows the type of transport nodes.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  members: :class:`list` of :class:`EdgeClusterMember` or ``None``
        :param members: EdgeCluster only supports homogeneous members. These member should
            be backed by either EdgeNode or PublicCloudGatewayNode.
            TransportNode type of these nodes should be the same.
            DeploymentType (VIRTUAL_MACHINE|PHYSICAL_MACHINE) of these
            EdgeNodes is recommended to be the same. EdgeCluster supports
            members of different deployment types.
        :type  node_rtep_ips: :class:`list` of :class:`NodeRtepIpsConfig` or ``None``
        :param node_rtep_ips: List of remote tunnel endpoint ipaddress configured on edge cluster
            for each transport node.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.allocation_rules = allocation_rules
        self.cluster_profile_bindings = cluster_profile_bindings
        self.deployment_type = deployment_type
        self.enable_inter_site_forwarding = enable_inter_site_forwarding
        self.member_node_type = member_node_type
        self.members = members
        self.node_rtep_ips = node_rtep_ips
        VapiStruct.__init__(self)


EdgeCluster._set_binding_type(type.StructType(
    'com.vmware.nsx.model.edge_cluster', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'allocation_rules': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'AllocationRule'))),
        'cluster_profile_bindings': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ClusterProfileTypeIdEntry'))),
        'deployment_type': type.OptionalType(type.StringType()),
        'enable_inter_site_forwarding': type.OptionalType(type.BooleanType()),
        'member_node_type': type.OptionalType(type.StringType()),
        'members': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'EdgeClusterMember'))),
        'node_rtep_ips': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NodeRtepIpsConfig'))),
    },
    EdgeCluster,
    False,
    None))



class EdgeClusterAllocationStatus(VapiStruct):
    """
    Allocation details of cluster and its members. Contains information of the
    edge nodes present in cluster, active and standby services of each node,
    utilization details of configured sub-pools. These allocation details can
    be monitored by customers to trigger migration of certain service contexts
    to different edge nodes, to balance the utilization of edge node resources.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'display_name': 'display_name',
                            'id': 'id',
                            'member_count': 'member_count',
                            'members': 'members',
                            }

    def __init__(self,
                 display_name=None,
                 id=None,
                 member_count=None,
                 members=None,
                ):
        """
        :type  display_name: :class:`str` or ``None``
        :param display_name: Display name of the edge cluster
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  id: :class:`str` or ``None``
        :param id: System allotted UUID of edge cluster.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  member_count: :class:`long` or ``None``
        :param member_count: Represents the number of edge nodes in the cluster. format: int32
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  members: :class:`list` of :class:`EdgeMemberAllocationStatus` or ``None``
        :param members: Allocation details of edge nodes present in the cluster.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.display_name = display_name
        self.id = id
        self.member_count = member_count
        self.members = members
        VapiStruct.__init__(self)


EdgeClusterAllocationStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.edge_cluster_allocation_status', {
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'member_count': type.OptionalType(type.IntegerType()),
        'members': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'EdgeMemberAllocationStatus'))),
    },
    EdgeClusterAllocationStatus,
    False,
    None))



class EdgeClusterInterSiteStatus(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    OVERALL_STATUS_UP = "UP"
    """


    """
    OVERALL_STATUS_DOWN = "DOWN"
    """


    """
    OVERALL_STATUS_DEGRADED = "DEGRADED"
    """


    """
    OVERALL_STATUS_UNKNOWN = "UNKNOWN"
    """


    """



    _canonical_to_pep_names = {
                            'edge_cluster_id': 'edge_cluster_id',
                            'edge_cluster_name': 'edge_cluster_name',
                            'last_update_timestamp': 'last_update_timestamp',
                            'member_status': 'member_status',
                            'overall_status': 'overall_status',
                            }

    def __init__(self,
                 edge_cluster_id=None,
                 edge_cluster_name=None,
                 last_update_timestamp=None,
                 member_status=None,
                 overall_status=None,
                ):
        """
        :type  edge_cluster_id: :class:`str` or ``None``
        :param edge_cluster_id: Id of the edge cluster whose status is being reported.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  edge_cluster_name: :class:`str` or ``None``
        :param edge_cluster_name: Name of the edge cluster whose status is being reported.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_update_timestamp: :class:`long` or ``None``
        :param last_update_timestamp: Timestamp when the edge cluster inter-site status was last updated.
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  member_status: :class:`list` of :class:`EdgeClusterMemberInterSiteStatus` or ``None``
        :param member_status: Per edge node inter-site status.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  overall_status: :class:`str` or ``None``
        :param overall_status: Possible values are: 
            
            * :attr:`EdgeClusterInterSiteStatus.OVERALL_STATUS_UP`
            * :attr:`EdgeClusterInterSiteStatus.OVERALL_STATUS_DOWN`
            * :attr:`EdgeClusterInterSiteStatus.OVERALL_STATUS_DEGRADED`
            * :attr:`EdgeClusterInterSiteStatus.OVERALL_STATUS_UNKNOWN`
            
             Overall status of all edge nodes IBGP status in the edge cluster.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.edge_cluster_id = edge_cluster_id
        self.edge_cluster_name = edge_cluster_name
        self.last_update_timestamp = last_update_timestamp
        self.member_status = member_status
        self.overall_status = overall_status
        VapiStruct.__init__(self)


EdgeClusterInterSiteStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.edge_cluster_inter_site_status', {
        'edge_cluster_id': type.OptionalType(type.StringType()),
        'edge_cluster_name': type.OptionalType(type.StringType()),
        'last_update_timestamp': type.OptionalType(type.IntegerType()),
        'member_status': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'EdgeClusterMemberInterSiteStatus'))),
        'overall_status': type.OptionalType(type.StringType()),
    },
    EdgeClusterInterSiteStatus,
    False,
    None))



class EdgeClusterListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`EdgeCluster` or ``None``
        :param results: Edge cluster list results
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


EdgeClusterListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.edge_cluster_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'EdgeCluster'))),
    },
    EdgeClusterListResult,
    False,
    None))



class EdgeClusterMember(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'description': 'description',
                            'display_name': 'display_name',
                            'member_index': 'member_index',
                            'transport_node_id': 'transport_node_id',
                            }

    def __init__(self,
                 description=None,
                 display_name=None,
                 member_index=None,
                 transport_node_id=None,
                ):
        """
        :type  description: :class:`str` or ``None``
        :param description: description of edge cluster member
        :type  display_name: :class:`str` or ``None``
        :param display_name: display name of edge cluster member
        :type  member_index: :class:`long` or ``None``
        :param member_index: System generated index for cluster member format: int32
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  transport_node_id: :class:`str` or ``None``
        :param transport_node_id: Identifier of the transport node backed by an Edge node
        """
        self.description = description
        self.display_name = display_name
        self.member_index = member_index
        self.transport_node_id = transport_node_id
        VapiStruct.__init__(self)


EdgeClusterMember._set_binding_type(type.StructType(
    'com.vmware.nsx.model.edge_cluster_member', {
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'member_index': type.OptionalType(type.IntegerType()),
        'transport_node_id': type.OptionalType(type.StringType()),
    },
    EdgeClusterMember,
    False,
    None))



class EdgeClusterMemberAllocationPool(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "EdgeClusterMemberAllocationPool"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    ALLOCATION_POOL_TYPE_LOADBALANCERALLOCATIONPOOL = "LoadBalancerAllocationPool"
    """


    """



    _canonical_to_pep_names = {
                            'allocation_pool_type': 'allocation_pool_type',
                            }

    def __init__(self,
                 allocation_pool_type='EdgeClusterMemberAllocationPool',
                ):
        """
        :type  allocation_pool_type: :class:`str`
        :param allocation_pool_type: Possible values are: 
            
            *
              :attr:`EdgeClusterMemberAllocationPool.ALLOCATION_POOL_TYPE_LOADBALANCERALLOCATIONPOOL`
            
             Types of logical router allocation pool based on services
        """
        self._allocation_pool_type = allocation_pool_type
        VapiStruct.__init__(self)

    @property
    def allocation_pool_type(self):
        """
        Return the discriminator value
        """
        return self._allocation_pool_type

EdgeClusterMemberAllocationPool._set_binding_type(type.StructType(
    'com.vmware.nsx.model.edge_cluster_member_allocation_pool', {
        'allocation_pool_type': type.StringType(),
    },
    EdgeClusterMemberAllocationPool,
    False,
    None))



class EdgeClusterMemberAllocationProfile(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    ALLOCATION_TYPE_MANUAL = "MANUAL"
    """


    """
    ALLOCATION_TYPE_AUTO = "AUTO"
    """


    """



    _canonical_to_pep_names = {
                            'allocation_pool': 'allocation_pool',
                            'allocation_type': 'allocation_type',
                            'enable_standby_relocation': 'enable_standby_relocation',
                            }

    def __init__(self,
                 allocation_pool=None,
                 allocation_type=None,
                 enable_standby_relocation=None,
                ):
        """
        :type  allocation_pool: :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param allocation_pool: Logical router allocation can be tracked for specific services and
            services may have their own hard limits and allocation sizes. For
            example load balancer pool should be specified if load balancer
            service will be attached to logical router.
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`EdgeClusterMemberAllocationPool`. When methods return a
            value of this class as a return value, the attribute will contain
            all the attributes defined in
            :class:`EdgeClusterMemberAllocationPool`.
        :type  allocation_type: :class:`str` or ``None``
        :param allocation_type: Possible values are: 
            
            * :attr:`EdgeClusterMemberAllocationProfile.ALLOCATION_TYPE_MANUAL`
            * :attr:`EdgeClusterMemberAllocationProfile.ALLOCATION_TYPE_AUTO`
            
            Allocation type is used to specify the mode used to allocate the
            LR. This is populated only for TIER1 logical router and for TIER0
            this will be null.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  enable_standby_relocation: :class:`bool` or ``None``
        :param enable_standby_relocation: Flag to enable the auto-relocation of standby service router
            running on edge cluster and node associated with the logical
            router. Only dynamically allocated tier1 logical routers are
            considered for the relocation.
        """
        self.allocation_pool = allocation_pool
        self.allocation_type = allocation_type
        self.enable_standby_relocation = enable_standby_relocation
        VapiStruct.__init__(self)


EdgeClusterMemberAllocationProfile._set_binding_type(type.StructType(
    'com.vmware.nsx.model.edge_cluster_member_allocation_profile', {
        'allocation_pool': type.OptionalType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'EdgeClusterMemberAllocationPool')])),
        'allocation_type': type.OptionalType(type.StringType()),
        'enable_standby_relocation': type.OptionalType(type.BooleanType()),
    },
    EdgeClusterMemberAllocationProfile,
    False,
    None))



class EdgeClusterMemberInterSiteStatus(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATUS_UP = "UP"
    """


    """
    STATUS_DOWN = "DOWN"
    """


    """
    STATUS_DEGRADED = "DEGRADED"
    """


    """
    STATUS_UNKNOWN = "UNKNOWN"
    """


    """



    _canonical_to_pep_names = {
                            'established_bgp_sessions': 'established_bgp_sessions',
                            'neighbor_status': 'neighbor_status',
                            'status': 'status',
                            'total_bgp_sessions': 'total_bgp_sessions',
                            'transport_node': 'transport_node',
                            }

    def __init__(self,
                 established_bgp_sessions=None,
                 neighbor_status=None,
                 status=None,
                 total_bgp_sessions=None,
                 transport_node=None,
                ):
        """
        :type  established_bgp_sessions: :class:`long` or ``None``
        :param established_bgp_sessions: Total number of current established inter-site IBGP sessions.
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  neighbor_status: :class:`list` of :class:`BgpNeighborStatusLiteDto` or ``None``
        :param neighbor_status: Inter-site BGP neighbor status.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  status: :class:`str` or ``None``
        :param status: Possible values are: 
            
            * :attr:`EdgeClusterMemberInterSiteStatus.STATUS_UP`
            * :attr:`EdgeClusterMemberInterSiteStatus.STATUS_DOWN`
            * :attr:`EdgeClusterMemberInterSiteStatus.STATUS_DEGRADED`
            * :attr:`EdgeClusterMemberInterSiteStatus.STATUS_UNKNOWN`
            
             Edge node IBGP status
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  total_bgp_sessions: :class:`long` or ``None``
        :param total_bgp_sessions: Total number of inter-site IBGP sessions. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  transport_node: :class:`ResourceReference` or ``None``
        :param transport_node: Edge node details from where the status is being retrived.
        """
        self.established_bgp_sessions = established_bgp_sessions
        self.neighbor_status = neighbor_status
        self.status = status
        self.total_bgp_sessions = total_bgp_sessions
        self.transport_node = transport_node
        VapiStruct.__init__(self)


EdgeClusterMemberInterSiteStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.edge_cluster_member_inter_site_status', {
        'established_bgp_sessions': type.OptionalType(type.IntegerType()),
        'neighbor_status': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'BgpNeighborStatusLiteDto'))),
        'status': type.OptionalType(type.StringType()),
        'total_bgp_sessions': type.OptionalType(type.IntegerType()),
        'transport_node': type.OptionalType(type.ReferenceType(__name__, 'ResourceReference')),
    },
    EdgeClusterMemberInterSiteStatus,
    False,
    None))



class EdgeClusterMemberStatus(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATUS_UP = "UP"
    """


    """
    STATUS_DOWN = "DOWN"
    """


    """
    STATUS_ADMIN_DOWN = "ADMIN_DOWN"
    """


    """
    STATUS_PARTIALLY_DISCONNECTED = "PARTIALLY_DISCONNECTED"
    """


    """
    STATUS_UNKNOWN = "UNKNOWN"
    """


    """



    _canonical_to_pep_names = {
                            'status': 'status',
                            'transport_node': 'transport_node',
                            }

    def __init__(self,
                 status=None,
                 transport_node=None,
                ):
        """
        :type  status: :class:`str` or ``None``
        :param status: Possible values are: 
            
            * :attr:`EdgeClusterMemberStatus.STATUS_UP`
            * :attr:`EdgeClusterMemberStatus.STATUS_DOWN`
            * :attr:`EdgeClusterMemberStatus.STATUS_ADMIN_DOWN`
            * :attr:`EdgeClusterMemberStatus.STATUS_PARTIALLY_DISCONNECTED`
            * :attr:`EdgeClusterMemberStatus.STATUS_UNKNOWN`
            
             Status of an edge node
        :type  transport_node: :class:`ResourceReference` or ``None``
        :param transport_node: Transport node backed by an Edge node.
        """
        self.status = status
        self.transport_node = transport_node
        VapiStruct.__init__(self)


EdgeClusterMemberStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.edge_cluster_member_status', {
        'status': type.OptionalType(type.StringType()),
        'transport_node': type.OptionalType(type.ReferenceType(__name__, 'ResourceReference')),
    },
    EdgeClusterMemberStatus,
    False,
    None))



class EdgeClusterMemberTransportNode(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'member_index': 'member_index',
                            'transport_node_id': 'transport_node_id',
                            }

    def __init__(self,
                 member_index=None,
                 transport_node_id=None,
                ):
        """
        :type  member_index: :class:`long` or ``None``
        :param member_index: System generated index for cluster member format: int32
        :type  transport_node_id: :class:`str` or ``None``
        :param transport_node_id: Identifier of the transport node backed by an Edge node
        """
        self.member_index = member_index
        self.transport_node_id = transport_node_id
        VapiStruct.__init__(self)


EdgeClusterMemberTransportNode._set_binding_type(type.StructType(
    'com.vmware.nsx.model.edge_cluster_member_transport_node', {
        'member_index': type.OptionalType(type.IntegerType()),
        'transport_node_id': type.OptionalType(type.StringType()),
    },
    EdgeClusterMemberTransportNode,
    False,
    None))



class EdgeClusterState(VapiStruct):
    """
    This holds the state of Edge Cluster. If there are errors in realizing EC
    outside of MP, it gives details of the components and specific errors.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATE_PENDING = "pending"
    """


    """
    STATE_IN_PROGRESS = "in_progress"
    """


    """
    STATE_SUCCESS = "success"
    """


    """
    STATE_FAILED = "failed"
    """


    """
    STATE_PARTIAL_SUCCESS = "partial_success"
    """


    """
    STATE_ORPHANED = "orphaned"
    """


    """
    STATE_UNKNOWN = "unknown"
    """


    """
    STATE_ERROR = "error"
    """


    """
    STATE_IN_SYNC = "in_sync"
    """


    """
    STATE_NOT_AVAILABLE = "NOT_AVAILABLE"
    """


    """
    STATE_VM_DEPLOYMENT_QUEUED = "VM_DEPLOYMENT_QUEUED"
    """


    """
    STATE_VM_DEPLOYMENT_IN_PROGRESS = "VM_DEPLOYMENT_IN_PROGRESS"
    """


    """
    STATE_VM_DEPLOYMENT_FAILED = "VM_DEPLOYMENT_FAILED"
    """


    """
    STATE_VM_POWER_ON_IN_PROGRESS = "VM_POWER_ON_IN_PROGRESS"
    """


    """
    STATE_VM_POWER_ON_FAILED = "VM_POWER_ON_FAILED"
    """


    """
    STATE_REGISTRATION_PENDING = "REGISTRATION_PENDING"
    """


    """
    STATE_NODE_NOT_READY = "NODE_NOT_READY"
    """


    """
    STATE_NODE_READY = "NODE_READY"
    """


    """
    STATE_VM_POWER_OFF_IN_PROGRESS = "VM_POWER_OFF_IN_PROGRESS"
    """


    """
    STATE_VM_POWER_OFF_FAILED = "VM_POWER_OFF_FAILED"
    """


    """
    STATE_VM_UNDEPLOY_IN_PROGRESS = "VM_UNDEPLOY_IN_PROGRESS"
    """


    """
    STATE_VM_UNDEPLOY_FAILED = "VM_UNDEPLOY_FAILED"
    """


    """
    STATE_VM_UNDEPLOY_SUCCESSFUL = "VM_UNDEPLOY_SUCCESSFUL"
    """


    """
    STATE_EDGE_CONFIG_ERROR = "EDGE_CONFIG_ERROR"
    """


    """
    STATE_VM_DEPLOYMENT_RESTARTED = "VM_DEPLOYMENT_RESTARTED"
    """


    """
    STATE_REGISTRATION_FAILED = "REGISTRATION_FAILED"
    """


    """
    STATE_TRANSPORT_NODE_SYNC_PENDING = "TRANSPORT_NODE_SYNC_PENDING"
    """


    """
    STATE_TRANSPORT_NODE_CONFIGURATION_MISSING = "TRANSPORT_NODE_CONFIGURATION_MISSING"
    """


    """
    STATE_EDGE_HARDWARE_NOT_SUPPORTED = "EDGE_HARDWARE_NOT_SUPPORTED"
    """


    """
    STATE_MULTIPLE_OVERLAY_TZS_NOT_SUPPORTED = "MULTIPLE_OVERLAY_TZS_NOT_SUPPORTED"
    """


    """
    STATE_TN_OVERLAY_TZ_IN_USE_BY_EDGE_CLUSTER = "TN_OVERLAY_TZ_IN_USE_BY_EDGE_CLUSTER"
    """


    """
    STATE_TZ_ENDPOINTS_NOT_SPECIFIED = "TZ_ENDPOINTS_NOT_SPECIFIED"
    """


    """
    STATE_NO_PNIC_PREPARED_IN_EDGE = "NO_PNIC_PREPARED_IN_EDGE"
    """


    """
    STATE_APPLIANCE_INTERNAL_ERROR = "APPLIANCE_INTERNAL_ERROR"
    """


    """
    STATE_VTEP_DHCP_NOT_SUPPORTED = "VTEP_DHCP_NOT_SUPPORTED"
    """


    """
    STATE_UNSUPPORTED_HOST_SWITCH_PROFILE = "UNSUPPORTED_HOST_SWITCH_PROFILE"
    """


    """
    STATE_UPLINK_HOST_SWITCH_PROFILE_NOT_SPECIFIED = "UPLINK_HOST_SWITCH_PROFILE_NOT_SPECIFIED"
    """


    """
    STATE_HOSTSWITCH_PROFILE_NOT_FOUND = "HOSTSWITCH_PROFILE_NOT_FOUND"
    """


    """
    STATE_LLDP_SEND_ENABLED_NOT_SUPPORTED = "LLDP_SEND_ENABLED_NOT_SUPPORTED"
    """


    """
    STATE_UNSUPPORTED_NAMED_TEAMING_POLICY = "UNSUPPORTED_NAMED_TEAMING_POLICY"
    """


    """
    STATE_LBSRCID_NOT_SUPPORTED_FOR_EDGE_VM = "LBSRCID_NOT_SUPPORTED_FOR_EDGE_VM"
    """


    """
    STATE_LACP_NOT_SUPPORTED_FOR_EDGE_VM = "LACP_NOT_SUPPORTED_FOR_EDGE_VM"
    """


    """
    STATE_STANDBY_UPLINKS_NOT_SUPPORTED_FOR_EDGE_VM = "STANDBY_UPLINKS_NOT_SUPPORTED_FOR_EDGE_VM"
    """


    """
    STATE_MULTIPLE_ACTIVE_UPLINKS_NOT_SUPPORTED_FOR_EDGE = "MULTIPLE_ACTIVE_UPLINKS_NOT_SUPPORTED_FOR_EDGE"
    """


    """
    STATE_UNSUPPORTED_LACP_LB_ALGO_FOR_NODE = "UNSUPPORTED_LACP_LB_ALGO_FOR_NODE"
    """


    """
    STATE_EDGE_NODE_VERSION_NOT_SUPPORTED = "EDGE_NODE_VERSION_NOT_SUPPORTED"
    """


    """
    STATE_NO_PNIC_SPECIFIED_IN_TN = "NO_PNIC_SPECIFIED_IN_TN"
    """


    """
    STATE_INVALID_PNIC_DEVICE_NAME = "INVALID_PNIC_DEVICE_NAME"
    """


    """
    STATE_TRANSPORT_NODE_READY = "TRANSPORT_NODE_READY"
    """


    """
    STATE_VM_NETWORK_EDIT_PENDING = "VM_NETWORK_EDIT_PENDING"
    """


    """
    STATE_UNSUPPORTED_DEFAULT_TEAMING_POLICY = "UNSUPPORTED_DEFAULT_TEAMING_POLICY"
    """


    """
    STATE_MPA_DISCONNECTED = "MPA_DISCONNECTED"
    """


    """
    STATE_VM_RENAME_PENDING = "VM_RENAME_PENDING"
    """


    """
    STATE_VM_CONFIG_EDIT_PENDING = "VM_CONFIG_EDIT_PENDING"
    """


    """
    STATE_VM_NETWORK_EDIT_FAILED = "VM_NETWORK_EDIT_FAILED"
    """


    """
    STATE_VM_RENAME_FAILED = "VM_RENAME_FAILED"
    """


    """
    STATE_VM_CONFIG_EDIT_FAILED = "VM_CONFIG_EDIT_FAILED"
    """


    """
    STATE_VM_CONFIG_DISCREPANCY = "VM_CONFIG_DISCREPANCY"
    """


    """
    STATE_VM_NODE_REFRESH_FAILED = "VM_NODE_REFRESH_FAILED"
    """


    """
    STATE_VM_PLACEMENT_REFRESH_FAILED = "VM_PLACEMENT_REFRESH_FAILED"
    """


    """
    STATE_REGISTRATION_TIMEDOUT = "REGISTRATION_TIMEDOUT"
    """


    """



    _canonical_to_pep_names = {
                            'details': 'details',
                            'failure_code': 'failure_code',
                            'failure_message': 'failure_message',
                            'state': 'state',
                            'pending_change_list': 'pending_change_list',
                            }

    def __init__(self,
                 details=None,
                 failure_code=None,
                 failure_message=None,
                 state=None,
                 pending_change_list=None,
                ):
        """
        :type  details: :class:`list` of :class:`ConfigurationStateElement` or ``None``
        :param details: Array of configuration state of various sub systems
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  failure_code: :class:`long` or ``None``
        :param failure_code: Error code format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  failure_message: :class:`str` or ``None``
        :param failure_message: Error message in case of failure
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  state: :class:`str` or ``None``
        :param state: Possible values are: 
            
            * :attr:`EdgeClusterState.STATE_PENDING`
            * :attr:`EdgeClusterState.STATE_IN_PROGRESS`
            * :attr:`EdgeClusterState.STATE_SUCCESS`
            * :attr:`EdgeClusterState.STATE_FAILED`
            * :attr:`EdgeClusterState.STATE_PARTIAL_SUCCESS`
            * :attr:`EdgeClusterState.STATE_ORPHANED`
            * :attr:`EdgeClusterState.STATE_UNKNOWN`
            * :attr:`EdgeClusterState.STATE_ERROR`
            * :attr:`EdgeClusterState.STATE_IN_SYNC`
            * :attr:`EdgeClusterState.STATE_NOT_AVAILABLE`
            * :attr:`EdgeClusterState.STATE_VM_DEPLOYMENT_QUEUED`
            * :attr:`EdgeClusterState.STATE_VM_DEPLOYMENT_IN_PROGRESS`
            * :attr:`EdgeClusterState.STATE_VM_DEPLOYMENT_FAILED`
            * :attr:`EdgeClusterState.STATE_VM_POWER_ON_IN_PROGRESS`
            * :attr:`EdgeClusterState.STATE_VM_POWER_ON_FAILED`
            * :attr:`EdgeClusterState.STATE_REGISTRATION_PENDING`
            * :attr:`EdgeClusterState.STATE_NODE_NOT_READY`
            * :attr:`EdgeClusterState.STATE_NODE_READY`
            * :attr:`EdgeClusterState.STATE_VM_POWER_OFF_IN_PROGRESS`
            * :attr:`EdgeClusterState.STATE_VM_POWER_OFF_FAILED`
            * :attr:`EdgeClusterState.STATE_VM_UNDEPLOY_IN_PROGRESS`
            * :attr:`EdgeClusterState.STATE_VM_UNDEPLOY_FAILED`
            * :attr:`EdgeClusterState.STATE_VM_UNDEPLOY_SUCCESSFUL`
            * :attr:`EdgeClusterState.STATE_EDGE_CONFIG_ERROR`
            * :attr:`EdgeClusterState.STATE_VM_DEPLOYMENT_RESTARTED`
            * :attr:`EdgeClusterState.STATE_REGISTRATION_FAILED`
            * :attr:`EdgeClusterState.STATE_TRANSPORT_NODE_SYNC_PENDING`
            *
              :attr:`EdgeClusterState.STATE_TRANSPORT_NODE_CONFIGURATION_MISSING`
            * :attr:`EdgeClusterState.STATE_EDGE_HARDWARE_NOT_SUPPORTED`
            * :attr:`EdgeClusterState.STATE_MULTIPLE_OVERLAY_TZS_NOT_SUPPORTED`
            *
              :attr:`EdgeClusterState.STATE_TN_OVERLAY_TZ_IN_USE_BY_EDGE_CLUSTER`
            * :attr:`EdgeClusterState.STATE_TZ_ENDPOINTS_NOT_SPECIFIED`
            * :attr:`EdgeClusterState.STATE_NO_PNIC_PREPARED_IN_EDGE`
            * :attr:`EdgeClusterState.STATE_APPLIANCE_INTERNAL_ERROR`
            * :attr:`EdgeClusterState.STATE_VTEP_DHCP_NOT_SUPPORTED`
            * :attr:`EdgeClusterState.STATE_UNSUPPORTED_HOST_SWITCH_PROFILE`
            *
              :attr:`EdgeClusterState.STATE_UPLINK_HOST_SWITCH_PROFILE_NOT_SPECIFIED`
            * :attr:`EdgeClusterState.STATE_HOSTSWITCH_PROFILE_NOT_FOUND`
            * :attr:`EdgeClusterState.STATE_LLDP_SEND_ENABLED_NOT_SUPPORTED`
            * :attr:`EdgeClusterState.STATE_UNSUPPORTED_NAMED_TEAMING_POLICY`
            * :attr:`EdgeClusterState.STATE_LBSRCID_NOT_SUPPORTED_FOR_EDGE_VM`
            * :attr:`EdgeClusterState.STATE_LACP_NOT_SUPPORTED_FOR_EDGE_VM`
            *
              :attr:`EdgeClusterState.STATE_STANDBY_UPLINKS_NOT_SUPPORTED_FOR_EDGE_VM`
            *
              :attr:`EdgeClusterState.STATE_MULTIPLE_ACTIVE_UPLINKS_NOT_SUPPORTED_FOR_EDGE`
            * :attr:`EdgeClusterState.STATE_UNSUPPORTED_LACP_LB_ALGO_FOR_NODE`
            * :attr:`EdgeClusterState.STATE_EDGE_NODE_VERSION_NOT_SUPPORTED`
            * :attr:`EdgeClusterState.STATE_NO_PNIC_SPECIFIED_IN_TN`
            * :attr:`EdgeClusterState.STATE_INVALID_PNIC_DEVICE_NAME`
            * :attr:`EdgeClusterState.STATE_TRANSPORT_NODE_READY`
            * :attr:`EdgeClusterState.STATE_VM_NETWORK_EDIT_PENDING`
            * :attr:`EdgeClusterState.STATE_UNSUPPORTED_DEFAULT_TEAMING_POLICY`
            * :attr:`EdgeClusterState.STATE_MPA_DISCONNECTED`
            * :attr:`EdgeClusterState.STATE_VM_RENAME_PENDING`
            * :attr:`EdgeClusterState.STATE_VM_CONFIG_EDIT_PENDING`
            * :attr:`EdgeClusterState.STATE_VM_NETWORK_EDIT_FAILED`
            * :attr:`EdgeClusterState.STATE_VM_RENAME_FAILED`
            * :attr:`EdgeClusterState.STATE_VM_CONFIG_EDIT_FAILED`
            * :attr:`EdgeClusterState.STATE_VM_CONFIG_DISCREPANCY`
            * :attr:`EdgeClusterState.STATE_VM_NODE_REFRESH_FAILED`
            * :attr:`EdgeClusterState.STATE_VM_PLACEMENT_REFRESH_FAILED`
            * :attr:`EdgeClusterState.STATE_REGISTRATION_TIMEDOUT`
            
            Gives details of state of desired configuration. Additional enums
            with more details on progress/success/error states are sent for
            edge node. The success states are NODE_READY and
            TRANSPORT_NODE_READY, pending states are {VM_DEPLOYMENT_QUEUED,
            VM_DEPLOYMENT_IN_PROGRESS, REGISTRATION_PENDING} and other values
            indicate failures. \"in_sync\" state indicates that the desired
            configuration has been received by the host to which it applies,
            but is not yet in effect. When the configuration is actually in
            effect, the state will change to \"success\". Please note, failed
            state is deprecated.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  pending_change_list: :class:`list` of :class:`str` or ``None``
        :param pending_change_list: Request identifier of the API which modified the entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.details = details
        self.failure_code = failure_code
        self.failure_message = failure_message
        self.state = state
        self.pending_change_list = pending_change_list
        VapiStruct.__init__(self)


EdgeClusterState._set_binding_type(type.StructType(
    'com.vmware.nsx.model.edge_cluster_state', {
        'details': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ConfigurationStateElement'))),
        'failure_code': type.OptionalType(type.IntegerType()),
        'failure_message': type.OptionalType(type.StringType()),
        'state': type.OptionalType(type.StringType()),
        'pending_change_list': type.OptionalType(type.ListType(type.StringType())),
    },
    EdgeClusterState,
    False,
    None))



class EdgeClusterStatus(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    EDGE_CLUSTER_STATUS_UP = "UP"
    """


    """
    EDGE_CLUSTER_STATUS_DOWN = "DOWN"
    """


    """
    EDGE_CLUSTER_STATUS_DEGRADED = "DEGRADED"
    """


    """
    EDGE_CLUSTER_STATUS_UNKNOWN = "UNKNOWN"
    """


    """



    _canonical_to_pep_names = {
                            'edge_cluster_id': 'edge_cluster_id',
                            'edge_cluster_status': 'edge_cluster_status',
                            'last_update_timestamp': 'last_update_timestamp',
                            'member_status': 'member_status',
                            }

    def __init__(self,
                 edge_cluster_id=None,
                 edge_cluster_status=None,
                 last_update_timestamp=None,
                 member_status=None,
                ):
        """
        :type  edge_cluster_id: :class:`str` or ``None``
        :param edge_cluster_id: Id of the edge cluster whose status is being reported
        :type  edge_cluster_status: :class:`str` or ``None``
        :param edge_cluster_status: Possible values are: 
            
            * :attr:`EdgeClusterStatus.EDGE_CLUSTER_STATUS_UP`
            * :attr:`EdgeClusterStatus.EDGE_CLUSTER_STATUS_DOWN`
            * :attr:`EdgeClusterStatus.EDGE_CLUSTER_STATUS_DEGRADED`
            * :attr:`EdgeClusterStatus.EDGE_CLUSTER_STATUS_UNKNOWN`
            
             Status of an edge node
        :type  last_update_timestamp: :class:`long` or ``None``
        :param last_update_timestamp: Timestamp when the cluster status was last updated format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  member_status: :class:`list` of :class:`EdgeClusterMemberStatus` or ``None``
        :param member_status: Per Edge Node Status
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.edge_cluster_id = edge_cluster_id
        self.edge_cluster_status = edge_cluster_status
        self.last_update_timestamp = last_update_timestamp
        self.member_status = member_status
        VapiStruct.__init__(self)


EdgeClusterStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.edge_cluster_status', {
        'edge_cluster_id': type.OptionalType(type.StringType()),
        'edge_cluster_status': type.OptionalType(type.StringType()),
        'last_update_timestamp': type.OptionalType(type.IntegerType()),
        'member_status': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'EdgeClusterMemberStatus'))),
    },
    EdgeClusterStatus,
    False,
    None))



class EdgeConfigurationState(VapiStruct):
    """
    This contains fields that captures state of Trackable entities. Edge and
    VPN state entities extend this object.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATE_PENDING = "pending"
    """


    """
    STATE_IN_PROGRESS = "in_progress"
    """


    """
    STATE_SUCCESS = "success"
    """


    """
    STATE_FAILED = "failed"
    """


    """
    STATE_PARTIAL_SUCCESS = "partial_success"
    """


    """
    STATE_ORPHANED = "orphaned"
    """


    """
    STATE_UNKNOWN = "unknown"
    """


    """
    STATE_ERROR = "error"
    """


    """
    STATE_IN_SYNC = "in_sync"
    """


    """
    STATE_NOT_AVAILABLE = "NOT_AVAILABLE"
    """


    """
    STATE_VM_DEPLOYMENT_QUEUED = "VM_DEPLOYMENT_QUEUED"
    """


    """
    STATE_VM_DEPLOYMENT_IN_PROGRESS = "VM_DEPLOYMENT_IN_PROGRESS"
    """


    """
    STATE_VM_DEPLOYMENT_FAILED = "VM_DEPLOYMENT_FAILED"
    """


    """
    STATE_VM_POWER_ON_IN_PROGRESS = "VM_POWER_ON_IN_PROGRESS"
    """


    """
    STATE_VM_POWER_ON_FAILED = "VM_POWER_ON_FAILED"
    """


    """
    STATE_REGISTRATION_PENDING = "REGISTRATION_PENDING"
    """


    """
    STATE_NODE_NOT_READY = "NODE_NOT_READY"
    """


    """
    STATE_NODE_READY = "NODE_READY"
    """


    """
    STATE_VM_POWER_OFF_IN_PROGRESS = "VM_POWER_OFF_IN_PROGRESS"
    """


    """
    STATE_VM_POWER_OFF_FAILED = "VM_POWER_OFF_FAILED"
    """


    """
    STATE_VM_UNDEPLOY_IN_PROGRESS = "VM_UNDEPLOY_IN_PROGRESS"
    """


    """
    STATE_VM_UNDEPLOY_FAILED = "VM_UNDEPLOY_FAILED"
    """


    """
    STATE_VM_UNDEPLOY_SUCCESSFUL = "VM_UNDEPLOY_SUCCESSFUL"
    """


    """
    STATE_EDGE_CONFIG_ERROR = "EDGE_CONFIG_ERROR"
    """


    """
    STATE_VM_DEPLOYMENT_RESTARTED = "VM_DEPLOYMENT_RESTARTED"
    """


    """
    STATE_REGISTRATION_FAILED = "REGISTRATION_FAILED"
    """


    """
    STATE_TRANSPORT_NODE_SYNC_PENDING = "TRANSPORT_NODE_SYNC_PENDING"
    """


    """
    STATE_TRANSPORT_NODE_CONFIGURATION_MISSING = "TRANSPORT_NODE_CONFIGURATION_MISSING"
    """


    """
    STATE_EDGE_HARDWARE_NOT_SUPPORTED = "EDGE_HARDWARE_NOT_SUPPORTED"
    """


    """
    STATE_MULTIPLE_OVERLAY_TZS_NOT_SUPPORTED = "MULTIPLE_OVERLAY_TZS_NOT_SUPPORTED"
    """


    """
    STATE_TN_OVERLAY_TZ_IN_USE_BY_EDGE_CLUSTER = "TN_OVERLAY_TZ_IN_USE_BY_EDGE_CLUSTER"
    """


    """
    STATE_TZ_ENDPOINTS_NOT_SPECIFIED = "TZ_ENDPOINTS_NOT_SPECIFIED"
    """


    """
    STATE_NO_PNIC_PREPARED_IN_EDGE = "NO_PNIC_PREPARED_IN_EDGE"
    """


    """
    STATE_APPLIANCE_INTERNAL_ERROR = "APPLIANCE_INTERNAL_ERROR"
    """


    """
    STATE_VTEP_DHCP_NOT_SUPPORTED = "VTEP_DHCP_NOT_SUPPORTED"
    """


    """
    STATE_UNSUPPORTED_HOST_SWITCH_PROFILE = "UNSUPPORTED_HOST_SWITCH_PROFILE"
    """


    """
    STATE_UPLINK_HOST_SWITCH_PROFILE_NOT_SPECIFIED = "UPLINK_HOST_SWITCH_PROFILE_NOT_SPECIFIED"
    """


    """
    STATE_HOSTSWITCH_PROFILE_NOT_FOUND = "HOSTSWITCH_PROFILE_NOT_FOUND"
    """


    """
    STATE_LLDP_SEND_ENABLED_NOT_SUPPORTED = "LLDP_SEND_ENABLED_NOT_SUPPORTED"
    """


    """
    STATE_UNSUPPORTED_NAMED_TEAMING_POLICY = "UNSUPPORTED_NAMED_TEAMING_POLICY"
    """


    """
    STATE_LBSRCID_NOT_SUPPORTED_FOR_EDGE_VM = "LBSRCID_NOT_SUPPORTED_FOR_EDGE_VM"
    """


    """
    STATE_LACP_NOT_SUPPORTED_FOR_EDGE_VM = "LACP_NOT_SUPPORTED_FOR_EDGE_VM"
    """


    """
    STATE_STANDBY_UPLINKS_NOT_SUPPORTED_FOR_EDGE_VM = "STANDBY_UPLINKS_NOT_SUPPORTED_FOR_EDGE_VM"
    """


    """
    STATE_MULTIPLE_ACTIVE_UPLINKS_NOT_SUPPORTED_FOR_EDGE = "MULTIPLE_ACTIVE_UPLINKS_NOT_SUPPORTED_FOR_EDGE"
    """


    """
    STATE_UNSUPPORTED_LACP_LB_ALGO_FOR_NODE = "UNSUPPORTED_LACP_LB_ALGO_FOR_NODE"
    """


    """
    STATE_EDGE_NODE_VERSION_NOT_SUPPORTED = "EDGE_NODE_VERSION_NOT_SUPPORTED"
    """


    """
    STATE_NO_PNIC_SPECIFIED_IN_TN = "NO_PNIC_SPECIFIED_IN_TN"
    """


    """
    STATE_INVALID_PNIC_DEVICE_NAME = "INVALID_PNIC_DEVICE_NAME"
    """


    """
    STATE_TRANSPORT_NODE_READY = "TRANSPORT_NODE_READY"
    """


    """
    STATE_VM_NETWORK_EDIT_PENDING = "VM_NETWORK_EDIT_PENDING"
    """


    """
    STATE_UNSUPPORTED_DEFAULT_TEAMING_POLICY = "UNSUPPORTED_DEFAULT_TEAMING_POLICY"
    """


    """
    STATE_MPA_DISCONNECTED = "MPA_DISCONNECTED"
    """


    """
    STATE_VM_RENAME_PENDING = "VM_RENAME_PENDING"
    """


    """
    STATE_VM_CONFIG_EDIT_PENDING = "VM_CONFIG_EDIT_PENDING"
    """


    """
    STATE_VM_NETWORK_EDIT_FAILED = "VM_NETWORK_EDIT_FAILED"
    """


    """
    STATE_VM_RENAME_FAILED = "VM_RENAME_FAILED"
    """


    """
    STATE_VM_CONFIG_EDIT_FAILED = "VM_CONFIG_EDIT_FAILED"
    """


    """
    STATE_VM_CONFIG_DISCREPANCY = "VM_CONFIG_DISCREPANCY"
    """


    """
    STATE_VM_NODE_REFRESH_FAILED = "VM_NODE_REFRESH_FAILED"
    """


    """
    STATE_VM_PLACEMENT_REFRESH_FAILED = "VM_PLACEMENT_REFRESH_FAILED"
    """


    """
    STATE_REGISTRATION_TIMEDOUT = "REGISTRATION_TIMEDOUT"
    """


    """



    _canonical_to_pep_names = {
                            'details': 'details',
                            'failure_code': 'failure_code',
                            'failure_message': 'failure_message',
                            'state': 'state',
                            'pending_change_list': 'pending_change_list',
                            }

    def __init__(self,
                 details=None,
                 failure_code=None,
                 failure_message=None,
                 state=None,
                 pending_change_list=None,
                ):
        """
        :type  details: :class:`list` of :class:`ConfigurationStateElement` or ``None``
        :param details: Array of configuration state of various sub systems
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  failure_code: :class:`long` or ``None``
        :param failure_code: Error code format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  failure_message: :class:`str` or ``None``
        :param failure_message: Error message in case of failure
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  state: :class:`str` or ``None``
        :param state: Possible values are: 
            
            * :attr:`EdgeConfigurationState.STATE_PENDING`
            * :attr:`EdgeConfigurationState.STATE_IN_PROGRESS`
            * :attr:`EdgeConfigurationState.STATE_SUCCESS`
            * :attr:`EdgeConfigurationState.STATE_FAILED`
            * :attr:`EdgeConfigurationState.STATE_PARTIAL_SUCCESS`
            * :attr:`EdgeConfigurationState.STATE_ORPHANED`
            * :attr:`EdgeConfigurationState.STATE_UNKNOWN`
            * :attr:`EdgeConfigurationState.STATE_ERROR`
            * :attr:`EdgeConfigurationState.STATE_IN_SYNC`
            * :attr:`EdgeConfigurationState.STATE_NOT_AVAILABLE`
            * :attr:`EdgeConfigurationState.STATE_VM_DEPLOYMENT_QUEUED`
            * :attr:`EdgeConfigurationState.STATE_VM_DEPLOYMENT_IN_PROGRESS`
            * :attr:`EdgeConfigurationState.STATE_VM_DEPLOYMENT_FAILED`
            * :attr:`EdgeConfigurationState.STATE_VM_POWER_ON_IN_PROGRESS`
            * :attr:`EdgeConfigurationState.STATE_VM_POWER_ON_FAILED`
            * :attr:`EdgeConfigurationState.STATE_REGISTRATION_PENDING`
            * :attr:`EdgeConfigurationState.STATE_NODE_NOT_READY`
            * :attr:`EdgeConfigurationState.STATE_NODE_READY`
            * :attr:`EdgeConfigurationState.STATE_VM_POWER_OFF_IN_PROGRESS`
            * :attr:`EdgeConfigurationState.STATE_VM_POWER_OFF_FAILED`
            * :attr:`EdgeConfigurationState.STATE_VM_UNDEPLOY_IN_PROGRESS`
            * :attr:`EdgeConfigurationState.STATE_VM_UNDEPLOY_FAILED`
            * :attr:`EdgeConfigurationState.STATE_VM_UNDEPLOY_SUCCESSFUL`
            * :attr:`EdgeConfigurationState.STATE_EDGE_CONFIG_ERROR`
            * :attr:`EdgeConfigurationState.STATE_VM_DEPLOYMENT_RESTARTED`
            * :attr:`EdgeConfigurationState.STATE_REGISTRATION_FAILED`
            * :attr:`EdgeConfigurationState.STATE_TRANSPORT_NODE_SYNC_PENDING`
            *
              :attr:`EdgeConfigurationState.STATE_TRANSPORT_NODE_CONFIGURATION_MISSING`
            * :attr:`EdgeConfigurationState.STATE_EDGE_HARDWARE_NOT_SUPPORTED`
            *
              :attr:`EdgeConfigurationState.STATE_MULTIPLE_OVERLAY_TZS_NOT_SUPPORTED`
            *
              :attr:`EdgeConfigurationState.STATE_TN_OVERLAY_TZ_IN_USE_BY_EDGE_CLUSTER`
            * :attr:`EdgeConfigurationState.STATE_TZ_ENDPOINTS_NOT_SPECIFIED`
            * :attr:`EdgeConfigurationState.STATE_NO_PNIC_PREPARED_IN_EDGE`
            * :attr:`EdgeConfigurationState.STATE_APPLIANCE_INTERNAL_ERROR`
            * :attr:`EdgeConfigurationState.STATE_VTEP_DHCP_NOT_SUPPORTED`
            *
              :attr:`EdgeConfigurationState.STATE_UNSUPPORTED_HOST_SWITCH_PROFILE`
            *
              :attr:`EdgeConfigurationState.STATE_UPLINK_HOST_SWITCH_PROFILE_NOT_SPECIFIED`
            * :attr:`EdgeConfigurationState.STATE_HOSTSWITCH_PROFILE_NOT_FOUND`
            *
              :attr:`EdgeConfigurationState.STATE_LLDP_SEND_ENABLED_NOT_SUPPORTED`
            *
              :attr:`EdgeConfigurationState.STATE_UNSUPPORTED_NAMED_TEAMING_POLICY`
            *
              :attr:`EdgeConfigurationState.STATE_LBSRCID_NOT_SUPPORTED_FOR_EDGE_VM`
            *
              :attr:`EdgeConfigurationState.STATE_LACP_NOT_SUPPORTED_FOR_EDGE_VM`
            *
              :attr:`EdgeConfigurationState.STATE_STANDBY_UPLINKS_NOT_SUPPORTED_FOR_EDGE_VM`
            *
              :attr:`EdgeConfigurationState.STATE_MULTIPLE_ACTIVE_UPLINKS_NOT_SUPPORTED_FOR_EDGE`
            *
              :attr:`EdgeConfigurationState.STATE_UNSUPPORTED_LACP_LB_ALGO_FOR_NODE`
            *
              :attr:`EdgeConfigurationState.STATE_EDGE_NODE_VERSION_NOT_SUPPORTED`
            * :attr:`EdgeConfigurationState.STATE_NO_PNIC_SPECIFIED_IN_TN`
            * :attr:`EdgeConfigurationState.STATE_INVALID_PNIC_DEVICE_NAME`
            * :attr:`EdgeConfigurationState.STATE_TRANSPORT_NODE_READY`
            * :attr:`EdgeConfigurationState.STATE_VM_NETWORK_EDIT_PENDING`
            *
              :attr:`EdgeConfigurationState.STATE_UNSUPPORTED_DEFAULT_TEAMING_POLICY`
            * :attr:`EdgeConfigurationState.STATE_MPA_DISCONNECTED`
            * :attr:`EdgeConfigurationState.STATE_VM_RENAME_PENDING`
            * :attr:`EdgeConfigurationState.STATE_VM_CONFIG_EDIT_PENDING`
            * :attr:`EdgeConfigurationState.STATE_VM_NETWORK_EDIT_FAILED`
            * :attr:`EdgeConfigurationState.STATE_VM_RENAME_FAILED`
            * :attr:`EdgeConfigurationState.STATE_VM_CONFIG_EDIT_FAILED`
            * :attr:`EdgeConfigurationState.STATE_VM_CONFIG_DISCREPANCY`
            * :attr:`EdgeConfigurationState.STATE_VM_NODE_REFRESH_FAILED`
            * :attr:`EdgeConfigurationState.STATE_VM_PLACEMENT_REFRESH_FAILED`
            * :attr:`EdgeConfigurationState.STATE_REGISTRATION_TIMEDOUT`
            
            Gives details of state of desired configuration. Additional enums
            with more details on progress/success/error states are sent for
            edge node. The success states are NODE_READY and
            TRANSPORT_NODE_READY, pending states are {VM_DEPLOYMENT_QUEUED,
            VM_DEPLOYMENT_IN_PROGRESS, REGISTRATION_PENDING} and other values
            indicate failures. \"in_sync\" state indicates that the desired
            configuration has been received by the host to which it applies,
            but is not yet in effect. When the configuration is actually in
            effect, the state will change to \"success\". Please note, failed
            state is deprecated.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  pending_change_list: :class:`list` of :class:`str` or ``None``
        :param pending_change_list: Request identifier of the API which modified the entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.details = details
        self.failure_code = failure_code
        self.failure_message = failure_message
        self.state = state
        self.pending_change_list = pending_change_list
        VapiStruct.__init__(self)


EdgeConfigurationState._set_binding_type(type.StructType(
    'com.vmware.nsx.model.edge_configuration_state', {
        'details': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ConfigurationStateElement'))),
        'failure_code': type.OptionalType(type.IntegerType()),
        'failure_message': type.OptionalType(type.StringType()),
        'state': type.OptionalType(type.StringType()),
        'pending_change_list': type.OptionalType(type.ListType(type.StringType())),
    },
    EdgeConfigurationState,
    False,
    None))



class EdgeHighAvailabilityProfile(VapiStruct):
    """
    Profile for BFD HA cluster setting

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "EdgeHighAvailabilityProfile"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'bfd_allowed_hops': 'bfd_allowed_hops',
                            'bfd_declare_dead_multiple': 'bfd_declare_dead_multiple',
                            'bfd_probe_interval': 'bfd_probe_interval',
                            'standby_relocation_config': 'standby_relocation_config',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            }

    def __init__(self,
                 bfd_allowed_hops=None,
                 bfd_declare_dead_multiple=None,
                 bfd_probe_interval=None,
                 standby_relocation_config=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='EdgeHighAvailabilityProfile',
                 tags=None,
                ):
        """
        :type  bfd_allowed_hops: :class:`long` or ``None``
        :param bfd_allowed_hops: BFD allowed hops format: int64
        :type  bfd_declare_dead_multiple: :class:`long` or ``None``
        :param bfd_declare_dead_multiple: Number of times a packet is missed before BFD declares the neighbor
            down. format: int64
        :type  bfd_probe_interval: :class:`long` or ``None``
        :param bfd_probe_interval: the time interval (in millisec) between probe packets for heartbeat
            purpose format: int64
        :type  standby_relocation_config: :class:`StandbyRelocationConfig` or ``None``
        :param standby_relocation_config: Standby service contexts relocation setting
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`ClusterProfile.RESOURCE_TYPE_EDGEHIGHAVAILABILITYPROFILE`
            *
              :attr:`ClusterProfile.RESOURCE_TYPE_BRIDGEHIGHAVAILABILITYCLUSTERPROFILE`
            
             Supported cluster profiles.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        """
        self.bfd_allowed_hops = bfd_allowed_hops
        self.bfd_declare_dead_multiple = bfd_declare_dead_multiple
        self.bfd_probe_interval = bfd_probe_interval
        self.standby_relocation_config = standby_relocation_config
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

EdgeHighAvailabilityProfile._set_binding_type(type.StructType(
    'com.vmware.nsx.model.edge_high_availability_profile', {
        'bfd_allowed_hops': type.OptionalType(type.IntegerType()),
        'bfd_declare_dead_multiple': type.OptionalType(type.IntegerType()),
        'bfd_probe_interval': type.OptionalType(type.IntegerType()),
        'standby_relocation_config': type.OptionalType(type.ReferenceType(__name__, 'StandbyRelocationConfig')),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
    },
    EdgeHighAvailabilityProfile,
    False,
    None))



class EdgeMemberAllocationStatus(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'allocated_services': 'allocated_services',
                            'allocation_pools': 'allocation_pools',
                            'member_index': 'member_index',
                            'node_display_name': 'node_display_name',
                            'node_id': 'node_id',
                            }

    def __init__(self,
                 allocated_services=None,
                 allocation_pools=None,
                 member_index=None,
                 node_display_name=None,
                 node_id=None,
                ):
        """
        :type  allocated_services: :class:`list` of :class:`AllocatedService` or ``None``
        :param allocated_services: List of services allocated on the edge node.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  allocation_pools: :class:`list` of :class:`AllocationPool` or ``None``
        :param allocation_pools: Allocation details of pools defined on the edge node.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  member_index: :class:`long` or ``None``
        :param member_index: System generated index for transport node backed by edge node.
            format: int32
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  node_display_name: :class:`str` or ``None``
        :param node_display_name: Display name of edge cluster member. Defaults to ID if not set.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  node_id: :class:`str` or ``None``
        :param node_id: System allotted UUID of edge node.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.allocated_services = allocated_services
        self.allocation_pools = allocation_pools
        self.member_index = member_index
        self.node_display_name = node_display_name
        self.node_id = node_id
        VapiStruct.__init__(self)


EdgeMemberAllocationStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.edge_member_allocation_status', {
        'allocated_services': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'AllocatedService'))),
        'allocation_pools': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'AllocationPool'))),
        'member_index': type.OptionalType(type.IntegerType()),
        'node_display_name': type.OptionalType(type.StringType()),
        'node_id': type.OptionalType(type.StringType()),
    },
    EdgeMemberAllocationStatus,
    False,
    None))



class EdgeNode(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "EdgeNode"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    DEPLOYMENT_TYPE_VIRTUAL_MACHINE = "VIRTUAL_MACHINE"
    """


    """
    DEPLOYMENT_TYPE_PHYSICAL_MACHINE = "PHYSICAL_MACHINE"
    """


    """
    DEPLOYMENT_TYPE_UNKNOWN = "UNKNOWN"
    """


    """



    _canonical_to_pep_names = {
                            'allocation_list': 'allocation_list',
                            'deployment_config': 'deployment_config',
                            'deployment_type': 'deployment_type',
                            'node_settings': 'node_settings',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'discovered_ip_addresses': 'discovered_ip_addresses',
                            'external_id': 'external_id',
                            'fqdn': 'fqdn',
                            'ip_addresses': 'ip_addresses',
                            }

    def __init__(self,
                 allocation_list=None,
                 deployment_config=None,
                 deployment_type=None,
                 node_settings=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='EdgeNode',
                 tags=None,
                 discovered_ip_addresses=None,
                 external_id=None,
                 fqdn=None,
                 ip_addresses=None,
                ):
        """
        :type  allocation_list: :class:`list` of :class:`str` or ``None``
        :param allocation_list: List of logical router ids to which this edge node is allocated.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  deployment_config: :class:`EdgeNodeDeploymentConfig` or ``None``
        :param deployment_config: When this configuration is specified, edge fabric node of
            deployment_type VIRTUAL_MACHINE will be deployed and registered
            with MP.
        :type  deployment_type: :class:`str` or ``None``
        :param deployment_type: Possible values are: 
            
            * :attr:`EdgeNode.DEPLOYMENT_TYPE_VIRTUAL_MACHINE`
            * :attr:`EdgeNode.DEPLOYMENT_TYPE_PHYSICAL_MACHINE`
            * :attr:`EdgeNode.DEPLOYMENT_TYPE_UNKNOWN`
            
             Supported edge deployment type.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  node_settings: :class:`EdgeNodeSettings` or ``None``
        :param node_settings: Reports the current configuration of the SSH, DHS, NTP and host
            name on this edge node. The deployment_config property is used
            during deployment and this counterpart property shows current
            values.
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Fabric node type, for example 'HostNode', 'EdgeNode' or
            'PublicCloudGatewayNode'
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  discovered_ip_addresses: :class:`list` of :class:`str` or ``None``
        :param discovered_ip_addresses: Discovered IP Addresses of the fabric node, version 4 or 6 format:
            ip
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  external_id: :class:`str` or ``None``
        :param external_id: ID of the Node maintained on the Node and used to recognize the
            Node
        :type  fqdn: :class:`str` or ``None``
        :param fqdn: Fully qualified domain name of the fabric node
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  ip_addresses: :class:`list` of :class:`str` or ``None``
        :param ip_addresses: IP Addresses of the Node, version 4 or 6. This property is
            mandatory for all nodes except for automatic deployment of edge
            virtual machine node. For automatic deployment, the ip address from
            management_port_subnets property will be considered. format: ip
        """
        self.allocation_list = allocation_list
        self.deployment_config = deployment_config
        self.deployment_type = deployment_type
        self.node_settings = node_settings
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        self.discovered_ip_addresses = discovered_ip_addresses
        self.external_id = external_id
        self.fqdn = fqdn
        self.ip_addresses = ip_addresses
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

EdgeNode._set_binding_type(type.StructType(
    'com.vmware.nsx.model.edge_node', {
        'allocation_list': type.OptionalType(type.ListType(type.StringType())),
        'deployment_config': type.OptionalType(type.ReferenceType(__name__, 'EdgeNodeDeploymentConfig')),
        'deployment_type': type.OptionalType(type.StringType()),
        'node_settings': type.OptionalType(type.ReferenceType(__name__, 'EdgeNodeSettings')),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'discovered_ip_addresses': type.OptionalType(type.ListType(type.StringType())),
        'external_id': type.OptionalType(type.StringType()),
        'fqdn': type.OptionalType(type.StringType()),
        'ip_addresses': type.OptionalType(type.ListType(type.StringType())),
    },
    EdgeNode,
    False,
    None))



class EdgeNodeDeploymentConfig(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    FORM_FACTOR_SMALL = "SMALL"
    """


    """
    FORM_FACTOR_MEDIUM = "MEDIUM"
    """


    """
    FORM_FACTOR_LARGE = "LARGE"
    """


    """
    FORM_FACTOR_XLARGE = "XLARGE"
    """


    """



    _canonical_to_pep_names = {
                            'form_factor': 'form_factor',
                            'node_user_settings': 'node_user_settings',
                            'vm_deployment_config': 'vm_deployment_config',
                            }

    def __init__(self,
                 form_factor=None,
                 node_user_settings=None,
                 vm_deployment_config=None,
                ):
        """
        :type  form_factor: :class:`str` or ``None``
        :param form_factor: Possible values are: 
            
            * :attr:`EdgeNodeDeploymentConfig.FORM_FACTOR_SMALL`
            * :attr:`EdgeNodeDeploymentConfig.FORM_FACTOR_MEDIUM`
            * :attr:`EdgeNodeDeploymentConfig.FORM_FACTOR_LARGE`
            * :attr:`EdgeNodeDeploymentConfig.FORM_FACTOR_XLARGE`
            
             Supported edge form factor.
        :type  node_user_settings: :class:`NodeUserSettings` or ``None``
        :param node_user_settings: Username and password settings for the node. Note - these settings
            will be honored only during node deployment. Post deployment, CLI
            must be used for changing the user settings, changes to these
            parameters will not have any effect.
        :type  vm_deployment_config: :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param vm_deployment_config: 
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`DeploymentConfig`. When methods return a value of this
            class as a return value, the attribute will contain all the
            attributes defined in :class:`DeploymentConfig`.
        """
        self.form_factor = form_factor
        self.node_user_settings = node_user_settings
        self.vm_deployment_config = vm_deployment_config
        VapiStruct.__init__(self)


EdgeNodeDeploymentConfig._set_binding_type(type.StructType(
    'com.vmware.nsx.model.edge_node_deployment_config', {
        'form_factor': type.OptionalType(type.StringType()),
        'node_user_settings': type.OptionalType(type.ReferenceType(__name__, 'NodeUserSettings')),
        'vm_deployment_config': type.OptionalType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'DeploymentConfig')])),
    },
    EdgeNodeDeploymentConfig,
    False,
    None))



class EdgeNodeSettings(VapiStruct):
    """
    The settings are used during deployment and consequent update of an edge,
    unless indicated otherwise. The settings are preferred over the deprecated
    settings in VsphereDeploymentConfig. The settings reflect the current
    configuraton on an edge node. If the settings lag with actual state on the
    edge, these may be refreshed at NSX Manager using API POST
    api/v1/transport-nodes
    /&lt;transport-node-id&gt;?action=refresh_node_configuration&resource_type=
    EdgeNode

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'allow_ssh_root_login': 'allow_ssh_root_login',
                            'dns_servers': 'dns_servers',
                            'enable_ssh': 'enable_ssh',
                            'hostname': 'hostname',
                            'ntp_servers': 'ntp_servers',
                            'search_domains': 'search_domains',
                            'syslog_servers': 'syslog_servers',
                            }

    def __init__(self,
                 allow_ssh_root_login=None,
                 dns_servers=None,
                 enable_ssh=None,
                 hostname=None,
                 ntp_servers=None,
                 search_domains=None,
                 syslog_servers=None,
                ):
        """
        :type  allow_ssh_root_login: :class:`bool` or ``None``
        :param allow_ssh_root_login: Allowing root SSH logins is not recommended for security reasons.
            Edit of this property is not supported when updating transport
            node. Use the CLI to change this property.
        :type  dns_servers: :class:`list` of :class:`str` or ``None``
        :param dns_servers: List of DNS servers. format: ip
        :type  enable_ssh: :class:`bool` or ``None``
        :param enable_ssh: Enabling SSH service is not recommended for security reasons.
        :type  hostname: :class:`str` or ``None``
        :param hostname: Host name or FQDN for edge node.
        :type  ntp_servers: :class:`list` of :class:`str` or ``None``
        :param ntp_servers: List of NTP servers. format: hostname-or-ipv4
        :type  search_domains: :class:`list` of :class:`str` or ``None``
        :param search_domains: List of domain names that are used to complete unqualified host
            names.
        :type  syslog_servers: :class:`list` of :class:`SyslogConfiguration` or ``None``
        :param syslog_servers: List of Syslog server configuration.
        """
        self.allow_ssh_root_login = allow_ssh_root_login
        self.dns_servers = dns_servers
        self.enable_ssh = enable_ssh
        self.hostname = hostname
        self.ntp_servers = ntp_servers
        self.search_domains = search_domains
        self.syslog_servers = syslog_servers
        VapiStruct.__init__(self)


EdgeNodeSettings._set_binding_type(type.StructType(
    'com.vmware.nsx.model.edge_node_settings', {
        'allow_ssh_root_login': type.OptionalType(type.BooleanType()),
        'dns_servers': type.OptionalType(type.ListType(type.StringType())),
        'enable_ssh': type.OptionalType(type.BooleanType()),
        'hostname': type.OptionalType(type.StringType()),
        'ntp_servers': type.OptionalType(type.ListType(type.StringType())),
        'search_domains': type.OptionalType(type.ListType(type.StringType())),
        'syslog_servers': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'SyslogConfiguration'))),
    },
    EdgeNodeSettings,
    False,
    None))



class EdgeTransportNodeDatapathMemoryPoolUsage(VapiStruct):
    """
    Datapath memory pool usage value.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'description': 'description',
                            'name': 'name',
                            'usage': 'usage',
                            }

    def __init__(self,
                 description=None,
                 name=None,
                 usage=None,
                ):
        """
        :type  description: :class:`str` or ``None``
        :param description: Description of the memory pool.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  name: :class:`str` or ``None``
        :param name: Name of the datapath memory pool as available on edge node CLI.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  usage: :class:`float` or ``None``
        :param usage: Percentage of memory pool in use.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.description = description
        self.name = name
        self.usage = usage
        VapiStruct.__init__(self)


EdgeTransportNodeDatapathMemoryPoolUsage._set_binding_type(type.StructType(
    'com.vmware.nsx.model.edge_transport_node_datapath_memory_pool_usage', {
        'description': type.OptionalType(type.StringType()),
        'name': type.OptionalType(type.StringType()),
        'usage': type.OptionalType(type.DoubleType()),
    },
    EdgeTransportNodeDatapathMemoryPoolUsage,
    False,
    None))



class EdgeTransportNodeDatapathMemoryUsage(VapiStruct):
    """
    Detailed view of the datapath memory usage. Details out the heap and per
    memory pool point in time usage.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'datapath_heap_usage': 'datapath_heap_usage',
                            'datapath_mem_pools_usage': 'datapath_mem_pools_usage',
                            'highest_datapath_mem_pool_usage': 'highest_datapath_mem_pool_usage',
                            'highest_datapath_mem_pool_usage_names': 'highest_datapath_mem_pool_usage_names',
                            }

    def __init__(self,
                 datapath_heap_usage=None,
                 datapath_mem_pools_usage=None,
                 highest_datapath_mem_pool_usage=None,
                 highest_datapath_mem_pool_usage_names=None,
                ):
        """
        :type  datapath_heap_usage: :class:`float` or ``None``
        :param datapath_heap_usage: Percentage of heap memory in use.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  datapath_mem_pools_usage: :class:`list` of :class:`EdgeTransportNodeDatapathMemoryPoolUsage` or ``None``
        :param datapath_mem_pools_usage: 
        :type  highest_datapath_mem_pool_usage: :class:`float` or ``None``
        :param highest_datapath_mem_pool_usage: Highest percentage usage value among datapath memory pools.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  highest_datapath_mem_pool_usage_names: :class:`list` of :class:`str` or ``None``
        :param highest_datapath_mem_pool_usage_names: 
        """
        self.datapath_heap_usage = datapath_heap_usage
        self.datapath_mem_pools_usage = datapath_mem_pools_usage
        self.highest_datapath_mem_pool_usage = highest_datapath_mem_pool_usage
        self.highest_datapath_mem_pool_usage_names = highest_datapath_mem_pool_usage_names
        VapiStruct.__init__(self)


EdgeTransportNodeDatapathMemoryUsage._set_binding_type(type.StructType(
    'com.vmware.nsx.model.edge_transport_node_datapath_memory_usage', {
        'datapath_heap_usage': type.OptionalType(type.DoubleType()),
        'datapath_mem_pools_usage': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'EdgeTransportNodeDatapathMemoryPoolUsage'))),
        'highest_datapath_mem_pool_usage': type.OptionalType(type.DoubleType()),
        'highest_datapath_mem_pool_usage_names': type.OptionalType(type.ListType(type.StringType())),
    },
    EdgeTransportNodeDatapathMemoryUsage,
    False,
    None))



class EdgeTransportNodeMemoryUsage(VapiStruct):
    """
    Point in time usage of system, datapath, swap and cache memory in edge
    node.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'cache_usage': 'cache_usage',
                            'datapath_mem_usage_details': 'datapath_mem_usage_details',
                            'datapath_total_usage': 'datapath_total_usage',
                            'swap_usage': 'swap_usage',
                            'system_mem_usage': 'system_mem_usage',
                            }

    def __init__(self,
                 cache_usage=None,
                 datapath_mem_usage_details=None,
                 datapath_total_usage=None,
                 swap_usage=None,
                 system_mem_usage=None,
                ):
        """
        :type  cache_usage: :class:`float` or ``None``
        :param cache_usage: Percentage of RAM on the system that can be flushed out to disk.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  datapath_mem_usage_details: :class:`EdgeTransportNodeDatapathMemoryUsage` or ``None``
        :param datapath_mem_usage_details: Detailed view of the datapath memory usage. Details out the heap
            and per memory pool point in time usage.
        :type  datapath_total_usage: :class:`float` or ``None``
        :param datapath_total_usage: Percentage of memory in use by datapath processes which includes
            RES and hugepage memory.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  swap_usage: :class:`float` or ``None``
        :param swap_usage: Percentage of swap disk in use.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_mem_usage: :class:`float` or ``None``
        :param system_mem_usage: Percentage of RAM in use on edge node.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.cache_usage = cache_usage
        self.datapath_mem_usage_details = datapath_mem_usage_details
        self.datapath_total_usage = datapath_total_usage
        self.swap_usage = swap_usage
        self.system_mem_usage = system_mem_usage
        VapiStruct.__init__(self)


EdgeTransportNodeMemoryUsage._set_binding_type(type.StructType(
    'com.vmware.nsx.model.edge_transport_node_memory_usage', {
        'cache_usage': type.OptionalType(type.DoubleType()),
        'datapath_mem_usage_details': type.OptionalType(type.ReferenceType(__name__, 'EdgeTransportNodeDatapathMemoryUsage')),
        'datapath_total_usage': type.OptionalType(type.DoubleType()),
        'swap_usage': type.OptionalType(type.DoubleType()),
        'system_mem_usage': type.OptionalType(type.DoubleType()),
    },
    EdgeTransportNodeMemoryUsage,
    False,
    None))



class EdgeUpgradeStatus(VapiStruct):
    """
    Status of edge upgrade

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATUS_SUCCESS = "SUCCESS"
    """


    """
    STATUS_FAILED = "FAILED"
    """


    """
    STATUS_IN_PROGRESS = "IN_PROGRESS"
    """


    """
    STATUS_NOT_STARTED = "NOT_STARTED"
    """


    """
    STATUS_PAUSING = "PAUSING"
    """


    """
    STATUS_PAUSED = "PAUSED"
    """


    """



    _canonical_to_pep_names = {
                            'can_skip': 'can_skip',
                            'component_type': 'component_type',
                            'current_version_node_summary': 'current_version_node_summary',
                            'details': 'details',
                            'node_count_at_target_version': 'node_count_at_target_version',
                            'percent_complete': 'percent_complete',
                            'pre_upgrade_status': 'pre_upgrade_status',
                            'status': 'status',
                            'target_component_version': 'target_component_version',
                            }

    def __init__(self,
                 can_skip=None,
                 component_type=None,
                 current_version_node_summary=None,
                 details=None,
                 node_count_at_target_version=None,
                 percent_complete=None,
                 pre_upgrade_status=None,
                 status=None,
                 target_component_version=None,
                ):
        """
        :type  can_skip: :class:`bool` or ``None``
        :param can_skip: Can the upgrade of the remaining units in this component be skipped
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  component_type: :class:`str` or ``None``
        :param component_type: Component type for the upgrade status
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  current_version_node_summary: :class:`NodeSummaryList` or ``None``
        :param current_version_node_summary: Mapping of current versions of nodes and counts of nodes at the
            respective versions.
        :type  details: :class:`str` or ``None``
        :param details: Details about the upgrade status
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  node_count_at_target_version: :class:`long` or ``None``
        :param node_count_at_target_version: Number of nodes of the type and at the component version format:
            int32
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  percent_complete: :class:`float` or ``None``
        :param percent_complete: Indicator of upgrade progress in percentage
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  pre_upgrade_status: :class:`UpgradeChecksExecutionStatus` or ``None``
        :param pre_upgrade_status: Pre-upgrade status of the component-type
        :type  status: :class:`str` or ``None``
        :param status: Possible values are: 
            
            * :attr:`EdgeUpgradeStatus.STATUS_SUCCESS`
            * :attr:`EdgeUpgradeStatus.STATUS_FAILED`
            * :attr:`EdgeUpgradeStatus.STATUS_IN_PROGRESS`
            * :attr:`EdgeUpgradeStatus.STATUS_NOT_STARTED`
            * :attr:`EdgeUpgradeStatus.STATUS_PAUSING`
            * :attr:`EdgeUpgradeStatus.STATUS_PAUSED`
            
             Upgrade status of component
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  target_component_version: :class:`str` or ``None``
        :param target_component_version: Target component version
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.can_skip = can_skip
        self.component_type = component_type
        self.current_version_node_summary = current_version_node_summary
        self.details = details
        self.node_count_at_target_version = node_count_at_target_version
        self.percent_complete = percent_complete
        self.pre_upgrade_status = pre_upgrade_status
        self.status = status
        self.target_component_version = target_component_version
        VapiStruct.__init__(self)


EdgeUpgradeStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.edge_upgrade_status', {
        'can_skip': type.OptionalType(type.BooleanType()),
        'component_type': type.OptionalType(type.StringType()),
        'current_version_node_summary': type.OptionalType(type.ReferenceType(__name__, 'NodeSummaryList')),
        'details': type.OptionalType(type.StringType()),
        'node_count_at_target_version': type.OptionalType(type.IntegerType()),
        'percent_complete': type.OptionalType(type.DoubleType()),
        'pre_upgrade_status': type.OptionalType(type.ReferenceType(__name__, 'UpgradeChecksExecutionStatus')),
        'status': type.OptionalType(type.StringType()),
        'target_component_version': type.OptionalType(type.StringType()),
    },
    EdgeUpgradeStatus,
    False,
    None))



class EffectiveIPAddressMemberListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`str` or ``None``
        :param results: Paged Collection of effective ip addresses for the given NSGroup
            format: address-or-block-or-range
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


EffectiveIPAddressMemberListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.effective_IP_address_member_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.StringType())),
    },
    EffectiveIPAddressMemberListResult,
    False,
    None))



class EffectiveIPInfo(VapiStruct):
    """
    List of effective ip address along with site id

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'effective_ips': 'effective_ips',
                            'site_id': 'site_id',
                            }

    def __init__(self,
                 effective_ips=None,
                 site_id=None,
                ):
        """
        :type  effective_ips: :class:`list` of :class:`str` or ``None``
        :param effective_ips: 
        :type  site_id: :class:`str` or ``None``
        :param site_id: Id of the site to which the effective IPs belong to
        """
        self.effective_ips = effective_ips
        self.site_id = site_id
        VapiStruct.__init__(self)


EffectiveIPInfo._set_binding_type(type.StructType(
    'com.vmware.nsx.model.effective_IP_info', {
        'effective_ips': type.OptionalType(type.ListType(type.StringType())),
        'site_id': type.OptionalType(type.StringType()),
    },
    EffectiveIPInfo,
    False,
    None))



class EffectiveMemberResourceListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`ResourceReference` or ``None``
        :param results: Paged Collection of resources which are the effective members of an
            NSGroup.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


EffectiveMemberResourceListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.effective_member_resource_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceReference'))),
    },
    EffectiveMemberResourceListResult,
    False,
    None))



class EffectiveMemberTypeListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    RESULTS_NSGROUP = "NSGroup"
    """


    """
    RESULTS_IPSET = "IPSet"
    """


    """
    RESULTS_MACSET = "MACSet"
    """


    """
    RESULTS_LOGICALSWITCH = "LogicalSwitch"
    """


    """
    RESULTS_LOGICALPORT = "LogicalPort"
    """


    """
    RESULTS_VIRTUALMACHINE = "VirtualMachine"
    """


    """
    RESULTS_DIRECTORYGROUP = "DirectoryGroup"
    """


    """
    RESULTS_VIRTUALNETWORKINTERFACE = "VirtualNetworkInterface"
    """


    """
    RESULTS_TRANSPORTNODE = "TransportNode"
    """


    """
    RESULTS_CLOUDNATIVESERVICEINSTANCE = "CloudNativeServiceInstance"
    """


    """
    RESULTS_PHYSICALSERVER = "PhysicalServer"
    """


    """



    _canonical_to_pep_names = {
                            'result_count': 'result_count',
                            'results': 'results',
                            }

    def __init__(self,
                 result_count=None,
                 results=None,
                ):
        """
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of the member types in the results array format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`str` or ``None``
        :param results: Possible values are: 
            
            * :attr:`EffectiveMemberTypeListResult.RESULTS_NSGROUP`
            * :attr:`EffectiveMemberTypeListResult.RESULTS_IPSET`
            * :attr:`EffectiveMemberTypeListResult.RESULTS_MACSET`
            * :attr:`EffectiveMemberTypeListResult.RESULTS_LOGICALSWITCH`
            * :attr:`EffectiveMemberTypeListResult.RESULTS_LOGICALPORT`
            * :attr:`EffectiveMemberTypeListResult.RESULTS_VIRTUALMACHINE`
            * :attr:`EffectiveMemberTypeListResult.RESULTS_DIRECTORYGROUP`
            *
              :attr:`EffectiveMemberTypeListResult.RESULTS_VIRTUALNETWORKINTERFACE`
            * :attr:`EffectiveMemberTypeListResult.RESULTS_TRANSPORTNODE`
            *
              :attr:`EffectiveMemberTypeListResult.RESULTS_CLOUDNATIVESERVICEINSTANCE`
            * :attr:`EffectiveMemberTypeListResult.RESULTS_PHYSICALSERVER`
            
             Collection of member types for the given NSGroup
        """
        self.result_count = result_count
        self.results = results
        VapiStruct.__init__(self)


EffectiveMemberTypeListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.effective_member_type_list_result', {
        'result_count': type.OptionalType(type.IntegerType()),
        'results': type.OptionalType(type.ListType(type.StringType())),
    },
    EffectiveMemberTypeListResult,
    False,
    None))



class EffectiveProfileListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`NSXProfileReference` or ``None``
        :param results: Paged Collection of profiles which are applied to an Entity
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


EffectiveProfileListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.effective_profile_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NSXProfileReference'))),
    },
    EffectiveProfileListResult,
    False,
    None))



class EgressRateShaper(VapiStruct):
    """
    A shaper that specifies egress rate properties in Mb/s

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "EgressRateShaper"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'average_bandwidth_mbps': 'average_bandwidth_mbps',
                            'burst_size_bytes': 'burst_size_bytes',
                            'peak_bandwidth_mbps': 'peak_bandwidth_mbps',
                            'enabled': 'enabled',
                            'resource_type': 'resource_type',
                            }

    def __init__(self,
                 average_bandwidth_mbps=None,
                 burst_size_bytes=None,
                 peak_bandwidth_mbps=None,
                 enabled=None,
                 resource_type='EgressRateShaper',
                ):
        """
        :type  average_bandwidth_mbps: :class:`long` or ``None``
        :param average_bandwidth_mbps: Average bandwidth in Mb/s format: int32
        :type  burst_size_bytes: :class:`long` or ``None``
        :param burst_size_bytes: Burst size in bytes format: int32
        :type  peak_bandwidth_mbps: :class:`long` or ``None``
        :param peak_bandwidth_mbps: Peak bandwidth in Mb/s format: int32
        :type  enabled: :class:`bool` or ``None``
        :param enabled: 
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`QosBaseRateShaper.RESOURCE_TYPE_INGRESSRATESHAPER`
            *
              :attr:`QosBaseRateShaper.RESOURCE_TYPE_INGRESSBROADCASTRATESHAPER`
            * :attr:`QosBaseRateShaper.RESOURCE_TYPE_EGRESSRATESHAPER`
        """
        self.average_bandwidth_mbps = average_bandwidth_mbps
        self.burst_size_bytes = burst_size_bytes
        self.peak_bandwidth_mbps = peak_bandwidth_mbps
        self.enabled = enabled
        self._resource_type = resource_type
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

EgressRateShaper._set_binding_type(type.StructType(
    'com.vmware.nsx.model.egress_rate_shaper', {
        'average_bandwidth_mbps': type.OptionalType(type.IntegerType()),
        'burst_size_bytes': type.OptionalType(type.IntegerType()),
        'peak_bandwidth_mbps': type.OptionalType(type.IntegerType()),
        'enabled': type.OptionalType(type.BooleanType()),
        'resource_type': type.StringType(),
    },
    EgressRateShaper,
    False,
    None))



class EmbeddedResource(VapiStruct):
    """
    Base class for resources that are embedded in other resources

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_owner': 'owner',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 owner=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  owner: :class:`OwnerResourceLink` or ``None``
        :param owner: Owner of this resource
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Identifier of the resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.owner = owner
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        VapiStruct.__init__(self)


EmbeddedResource._set_binding_type(type.StructType(
    'com.vmware.nsx.model.embedded_resource', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_owner': type.OptionalType(type.ReferenceType(__name__, 'OwnerResourceLink')),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
    },
    EmbeddedResource,
    False,
    None))



class Endpoint(VapiStruct):
    """
    An Endpoint object is part of HostSwitch configuration in TransportNode

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'default_gateway': 'default_gateway',
                            'device_name': 'device_name',
                            'ip': 'ip',
                            'label': 'label',
                            'mac': 'mac',
                            'subnet_mask': 'subnet_mask',
                            }

    def __init__(self,
                 default_gateway=None,
                 device_name=None,
                 ip=None,
                 label=None,
                 mac=None,
                 subnet_mask=None,
                ):
        """
        :type  default_gateway: :class:`str` or ``None``
        :param default_gateway: Gateway IP format: ip
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  device_name: :class:`str` or ``None``
        :param device_name: Name of the virtual tunnel endpoint
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  ip: :class:`str` or ``None``
        :param ip: Depending upon the EndpointIpConfig used in HostSwitch, IP could be
            allocated either from DHCP (default) or from Static IP Pool.
            format: ip
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  label: :class:`long` or ``None``
        :param label: Unique label for this Endpoint format: int32
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  mac: :class:`str` or ``None``
        :param mac: MAC address format: mac-address
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  subnet_mask: :class:`str` or ``None``
        :param subnet_mask: Subnet mask format: ip
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.default_gateway = default_gateway
        self.device_name = device_name
        self.ip = ip
        self.label = label
        self.mac = mac
        self.subnet_mask = subnet_mask
        VapiStruct.__init__(self)


Endpoint._set_binding_type(type.StructType(
    'com.vmware.nsx.model.endpoint', {
        'default_gateway': type.OptionalType(type.StringType()),
        'device_name': type.OptionalType(type.StringType()),
        'ip': type.OptionalType(type.StringType()),
        'label': type.OptionalType(type.IntegerType()),
        'mac': type.OptionalType(type.StringType()),
        'subnet_mask': type.OptionalType(type.StringType()),
    },
    Endpoint,
    False,
    None))



class ErrorInfo(VapiStruct):
    """
    Error information

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'error_message': 'error_message',
                            'timestamp': 'timestamp',
                            }

    def __init__(self,
                 error_message=None,
                 timestamp=None,
                ):
        """
        :type  error_message: :class:`str` or ``None``
        :param error_message: Error message
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  timestamp: :class:`long` or ``None``
        :param timestamp: Timestamp when the error occurred format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.error_message = error_message
        self.timestamp = timestamp
        VapiStruct.__init__(self)


ErrorInfo._set_binding_type(type.StructType(
    'com.vmware.nsx.model.error_info', {
        'error_message': type.OptionalType(type.StringType()),
        'timestamp': type.OptionalType(type.IntegerType()),
    },
    ErrorInfo,
    False,
    None))



class ErrorResolverInfo(VapiStruct):
    """
    Metadata related to a given error_id

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'error_id': 'error_id',
                            'resolver_present': 'resolver_present',
                            'user_metadata': 'user_metadata',
                            }

    def __init__(self,
                 error_id=None,
                 resolver_present=None,
                 user_metadata=None,
                ):
        """
        :type  error_id: :class:`long` or ``None``
        :param error_id: The error id for which metadata information is needed format: int64
        :type  resolver_present: :class:`bool` or ``None``
        :param resolver_present: Indicates whether there is a resolver associated with the error or
            not
        :type  user_metadata: :class:`ErrorResolverUserMetadata` or ``None``
        :param user_metadata: User supplied metadata that might be required by the resolver
        """
        self.error_id = error_id
        self.resolver_present = resolver_present
        self.user_metadata = user_metadata
        VapiStruct.__init__(self)


ErrorResolverInfo._set_binding_type(type.StructType(
    'com.vmware.nsx.model.error_resolver_info', {
        'error_id': type.OptionalType(type.IntegerType()),
        'resolver_present': type.OptionalType(type.BooleanType()),
        'user_metadata': type.OptionalType(type.ReferenceType(__name__, 'ErrorResolverUserMetadata')),
    },
    ErrorResolverInfo,
    False,
    None))



class ErrorResolverInfoList(VapiStruct):
    """
    Collection of all registered ErrorResolverInfo

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'results': 'results',
                            }

    def __init__(self,
                 results=None,
                ):
        """
        :type  results: :class:`list` of :class:`ErrorResolverInfo` or ``None``
        :param results: ErrorResolverInfo list
        """
        self.results = results
        VapiStruct.__init__(self)


ErrorResolverInfoList._set_binding_type(type.StructType(
    'com.vmware.nsx.model.error_resolver_info_list', {
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ErrorResolverInfo'))),
    },
    ErrorResolverInfoList,
    False,
    None))



class ErrorResolverMetadata(VapiStruct):
    """
    Error along with its metadata

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'entity_id': 'entity_id',
                            'error_id': 'error_id',
                            'system_metadata': 'system_metadata',
                            'user_metadata': 'user_metadata',
                            }

    def __init__(self,
                 entity_id=None,
                 error_id=None,
                 system_metadata=None,
                 user_metadata=None,
                ):
        """
        :type  entity_id: :class:`str` or ``None``
        :param entity_id: The entity/node UUID where the error has occurred.
        :type  error_id: :class:`long` or ``None``
        :param error_id: The error id as reported by the entity where the error occurred.
            format: int64
        :type  system_metadata: :class:`ErrorResolverSystemMetadata` or ``None``
        :param system_metadata: This can come from some external system like syslog collector
        :type  user_metadata: :class:`ErrorResolverUserMetadata` or ``None``
        :param user_metadata: User supplied metadata that might be required by the resolver
        """
        self.entity_id = entity_id
        self.error_id = error_id
        self.system_metadata = system_metadata
        self.user_metadata = user_metadata
        VapiStruct.__init__(self)


ErrorResolverMetadata._set_binding_type(type.StructType(
    'com.vmware.nsx.model.error_resolver_metadata', {
        'entity_id': type.OptionalType(type.StringType()),
        'error_id': type.OptionalType(type.IntegerType()),
        'system_metadata': type.OptionalType(type.ReferenceType(__name__, 'ErrorResolverSystemMetadata')),
        'user_metadata': type.OptionalType(type.ReferenceType(__name__, 'ErrorResolverUserMetadata')),
    },
    ErrorResolverMetadata,
    False,
    None))



class ErrorResolverMetadataList(VapiStruct):
    """
    List of errors with their metadata

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'errors': 'errors',
                            }

    def __init__(self,
                 errors=None,
                ):
        """
        :type  errors: :class:`list` of :class:`ErrorResolverMetadata` or ``None``
        :param errors: List of errors with their corresponding metadata.
        """
        self.errors = errors
        VapiStruct.__init__(self)


ErrorResolverMetadataList._set_binding_type(type.StructType(
    'com.vmware.nsx.model.error_resolver_metadata_list', {
        'errors': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ErrorResolverMetadata'))),
    },
    ErrorResolverMetadataList,
    False,
    None))



class ErrorResolverSystemMetadata(VapiStruct):
    """
    Metadata fetched from an external system like Syslog or LogInsight.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'value': 'value',
                            }

    def __init__(self,
                 value=None,
                ):
        """
        :type  value: :class:`str` or ``None``
        :param value: The value fetched from another system
        """
        self.value = value
        VapiStruct.__init__(self)


ErrorResolverSystemMetadata._set_binding_type(type.StructType(
    'com.vmware.nsx.model.error_resolver_system_metadata', {
        'value': type.OptionalType(type.StringType()),
    },
    ErrorResolverSystemMetadata,
    False,
    None))



class ErrorResolverUserInputData(VapiStruct):
    """
    Corresponds to one property entered by the user

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    DATA_TYPE_TEXT = "TEXT"
    """


    """
    DATA_TYPE_NUMBER = "NUMBER"
    """


    """
    DATA_TYPE_PASSWORD = "PASSWORD"
    """


    """



    _canonical_to_pep_names = {
                            'data_type': 'data_type',
                            'property_name': 'property_name',
                            'property_value': 'property_value',
                            }

    def __init__(self,
                 data_type=None,
                 property_name=None,
                 property_value=None,
                ):
        """
        :type  data_type: :class:`str` or ``None``
        :param data_type: Possible values are: 
            
            * :attr:`ErrorResolverUserInputData.DATA_TYPE_TEXT`
            * :attr:`ErrorResolverUserInputData.DATA_TYPE_NUMBER`
            * :attr:`ErrorResolverUserInputData.DATA_TYPE_PASSWORD`
            
             The datatype of the given property. Useful for data validation
        :type  property_name: :class:`str` or ``None``
        :param property_name: Name of the property supplied by the user
        :type  property_value: :class:`str` or ``None``
        :param property_value: The value associated with the above property
        """
        self.data_type = data_type
        self.property_name = property_name
        self.property_value = property_value
        VapiStruct.__init__(self)


ErrorResolverUserInputData._set_binding_type(type.StructType(
    'com.vmware.nsx.model.error_resolver_user_input_data', {
        'data_type': type.OptionalType(type.StringType()),
        'property_name': type.OptionalType(type.StringType()),
        'property_value': type.OptionalType(type.StringType()),
    },
    ErrorResolverUserInputData,
    False,
    None))



class ErrorResolverUserMetadata(VapiStruct):
    """
    User supplied metadata needed for resolving errors

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'user_input_list': 'user_input_list',
                            }

    def __init__(self,
                 user_input_list=None,
                ):
        """
        :type  user_input_list: :class:`list` of :class:`ErrorResolverUserInputData` or ``None``
        :param user_input_list: List of user supplied input data.
        """
        self.user_input_list = user_input_list
        VapiStruct.__init__(self)


ErrorResolverUserMetadata._set_binding_type(type.StructType(
    'com.vmware.nsx.model.error_resolver_user_metadata', {
        'user_input_list': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ErrorResolverUserInputData'))),
    },
    ErrorResolverUserMetadata,
    False,
    None))



class EsxGlobalOpaqueConfig(VapiStruct):
    """
    ESX global opaque configuration

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "EsxGlobalOpaqueConfig"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'opaque_config': 'opaque_config',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            }

    def __init__(self,
                 opaque_config=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='EsxGlobalOpaqueConfig',
                 tags=None,
                ):
        """
        :type  opaque_config: :class:`list` of :class:`KeyValuePair` or ``None``
        :param opaque_config: A list of global opaque configuration for ESX hosts.
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`GlobalConfigs.RESOURCE_TYPE_SWITCHINGGLOBALCONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_ROUTINGGLOBALCONFIG`
            *
              :attr:`GlobalConfigs.RESOURCE_TYPE_OPERATIONCOLLECTORGLOBALCONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_FIREWALLGLOBALCONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_ESXGLOBALOPAQUECONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_SECURITYGLOBALCONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_FIPSGLOBALCONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_FEDERATIONGLOBALCONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_IDSGLOBALCONFIG`
            
             Valid Global configuration types
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        """
        self.opaque_config = opaque_config
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

EsxGlobalOpaqueConfig._set_binding_type(type.StructType(
    'com.vmware.nsx.model.esx_global_opaque_config', {
        'opaque_config': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'KeyValuePair'))),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
    },
    EsxGlobalOpaqueConfig,
    False,
    None))



class EtherTypeNSService(VapiStruct):
    """
    An NSService element that represents an ethertype protocol

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "EtherTypeNSService"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'ether_type': 'ether_type',
                            'resource_type': 'resource_type',
                            }

    def __init__(self,
                 ether_type=None,
                 resource_type='EtherTypeNSService',
                ):
        """
        :type  ether_type: :class:`long` or ``None``
        :param ether_type: Type of the encapsulated protocol format: int64
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`NSServiceElement.RESOURCE_TYPE_ETHERTYPENSSERVICE`
            * :attr:`NSServiceElement.RESOURCE_TYPE_IPPROTOCOLNSSERVICE`
            * :attr:`NSServiceElement.RESOURCE_TYPE_IGMPTYPENSSERVICE`
            * :attr:`NSServiceElement.RESOURCE_TYPE_ICMPTYPENSSERVICE`
            * :attr:`NSServiceElement.RESOURCE_TYPE_ALGTYPENSSERVICE`
            * :attr:`NSServiceElement.RESOURCE_TYPE_L4PORTSETNSSERVICE`
            
             The specific type of NSServiceElement
        """
        self.ether_type = ether_type
        self._resource_type = resource_type
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

EtherTypeNSService._set_binding_type(type.StructType(
    'com.vmware.nsx.model.ether_type_NS_service', {
        'ether_type': type.OptionalType(type.IntegerType()),
        'resource_type': type.StringType(),
    },
    EtherTypeNSService,
    False,
    None))



class EthernetHeader(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'dst_mac': 'dst_mac',
                            'eth_type': 'eth_type',
                            'src_mac': 'src_mac',
                            }

    def __init__(self,
                 dst_mac=None,
                 eth_type=None,
                 src_mac=None,
                ):
        """
        :type  dst_mac: :class:`str` or ``None``
        :param dst_mac: The destination MAC address of form:
            \"^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$\". For example:
            00:00:00:00:00:00.
        :type  eth_type: :class:`long` or ``None``
        :param eth_type: This field defaults to IPv4. format: int64
        :type  src_mac: :class:`str` or ``None``
        :param src_mac: The source MAC address of form:
            \"^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$\". For example:
            00:00:00:00:00:00.
        """
        self.dst_mac = dst_mac
        self.eth_type = eth_type
        self.src_mac = src_mac
        VapiStruct.__init__(self)


EthernetHeader._set_binding_type(type.StructType(
    'com.vmware.nsx.model.ethernet_header', {
        'dst_mac': type.OptionalType(type.StringType()),
        'eth_type': type.OptionalType(type.IntegerType()),
        'src_mac': type.OptionalType(type.StringType()),
    },
    EthernetHeader,
    False,
    None))



class EventListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`MonitoringEvent` or ``None``
        :param results: List of events defined
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


EventListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.event_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'MonitoringEvent'))),
    },
    EventListResult,
    False,
    None))



class ExcludeList(VapiStruct):
    """
    List of entities where Distributed Firewall will not be enforced. Exclusion
    List can contain NSGroup(s) or LogicalPort(s) or LogicalSwitch(es) to
    exclude Distributed Firewall enforcement.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'member_count': 'member_count',
                            'members': 'members',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 member_count=None,
                 members=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  member_count: :class:`long` or ``None``
        :param member_count: Total number of members present in Exclude List. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  members: :class:`list` of :class:`ResourceReference` or ``None``
        :param members: List of members in Exclusion List
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.member_count = member_count
        self.members = members
        VapiStruct.__init__(self)


ExcludeList._set_binding_type(type.StructType(
    'com.vmware.nsx.model.exclude_list', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'member_count': type.OptionalType(type.IntegerType()),
        'members': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceReference'))),
    },
    ExcludeList,
    False,
    None))



class ExtraConfig(VapiStruct):
    """
    Extra config is intended for supporting vendor specific configuration on
    the data path, it can be set as key value string pairs on either logical
    switch or logical port. If it was set on logical switch, it will be
    inherited automatically by logical ports in it. Also logical port setting
    will override logical switch setting if specific key was dual set on both
    logical switch and logical port.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'config_pair': 'config_pair',
                            }

    def __init__(self,
                 config_pair=None,
                ):
        """
        :type  config_pair: :class:`UnboundedKeyValuePair` or ``None``
        :param config_pair: Key value pair in string for the configuration
        """
        self.config_pair = config_pair
        VapiStruct.__init__(self)


ExtraConfig._set_binding_type(type.StructType(
    'com.vmware.nsx.model.extra_config', {
        'config_pair': type.OptionalType(type.ReferenceType(__name__, 'UnboundedKeyValuePair')),
    },
    ExtraConfig,
    False,
    None))



class ExtraConfigHostSwitchProfile(VapiStruct):
    """
    Profile for extra configs in host switch

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "ExtraConfigHostSwitchProfile"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'extra_configs': 'extra_configs',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'required_capabilities': 'required_capabilities',
                            }

    def __init__(self,
                 extra_configs=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='ExtraConfigHostSwitchProfile',
                 tags=None,
                 required_capabilities=None,
                ):
        """
        :type  extra_configs: :class:`list` of :class:`ExtraConfig` or ``None``
        :param extra_configs: list of extra configs
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            *
              :attr:`BaseHostSwitchProfile.RESOURCE_TYPE_UPLINKHOSTSWITCHPROFILE`
            * :attr:`BaseHostSwitchProfile.RESOURCE_TYPE_LLDPHOSTSWITCHPROFILE`
            * :attr:`BaseHostSwitchProfile.RESOURCE_TYPE_NIOCPROFILE`
            *
              :attr:`BaseHostSwitchProfile.RESOURCE_TYPE_EXTRACONFIGHOSTSWITCHPROFILE`
            
             Supported HostSwitch profiles.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  required_capabilities: :class:`list` of :class:`str` or ``None``
        :param required_capabilities: 
        """
        self.extra_configs = extra_configs
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        self.required_capabilities = required_capabilities
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

ExtraConfigHostSwitchProfile._set_binding_type(type.StructType(
    'com.vmware.nsx.model.extra_config_host_switch_profile', {
        'extra_configs': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ExtraConfig'))),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'required_capabilities': type.OptionalType(type.ListType(type.StringType())),
    },
    ExtraConfigHostSwitchProfile,
    False,
    None))



class FailedNodeSupportBundleResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'error_code': 'error_code',
                            'error_message': 'error_message',
                            'node_display_name': 'node_display_name',
                            'node_id': 'node_id',
                            }

    def __init__(self,
                 error_code=None,
                 error_message=None,
                 node_display_name=None,
                 node_id=None,
                ):
        """
        :type  error_code: :class:`str` or ``None``
        :param error_code: Error code
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  error_message: :class:`str` or ``None``
        :param error_message: Error message
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  node_display_name: :class:`str` or ``None``
        :param node_display_name: Display name of node
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  node_id: :class:`str` or ``None``
        :param node_id: UUID of node
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.error_code = error_code
        self.error_message = error_message
        self.node_display_name = node_display_name
        self.node_id = node_id
        VapiStruct.__init__(self)


FailedNodeSupportBundleResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.failed_node_support_bundle_result', {
        'error_code': type.OptionalType(type.StringType()),
        'error_message': type.OptionalType(type.StringType()),
        'node_display_name': type.OptionalType(type.StringType()),
        'node_id': type.OptionalType(type.StringType()),
    },
    FailedNodeSupportBundleResult,
    False,
    None))



class FailureDomain(VapiStruct):
    """
    Failure Domain is engineered to be isolated from failures in other failure
    domains, and to provide inexpensive, low-latency network connectivity to
    other failure domains in the same region. We support failure domain only on
    edge transport node. Like you can consider one rack as one failure domain
    and place active-standby contexts like logical router, DHCP and MDProxy in
    two different failure domains (racks). So failure of a single rack (FD)
    does not impact any services and other rack (FD) will continue to handle
    traffic. Initially system creates one default failure domain. For any edge
    transport node, if failure domains is not given, it will be mapped to
    default system generated failure domain. You can't update
    preferred_active_edge_services flag for system generated default failure
    domain. It will be unset which means that failure domain can be used for
    both active and standby allocation.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'preferred_active_edge_services': 'preferred_active_edge_services',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 preferred_active_edge_services=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  preferred_active_edge_services: :class:`bool` or ``None``
        :param preferred_active_edge_services: Set preference for edge transport node failure domain which will be
            considered while doing auto placement of logical router, DHCP and
            MDProxy on edge node. true: For preemptive failover mode, active
            edge cluster member allocation preferes this failure domain. false:
            For preemptive failover mode, standby edge cluster member
            allocation preferes this failure domain. Default will be unset. It
            means no explicit preference.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.preferred_active_edge_services = preferred_active_edge_services
        VapiStruct.__init__(self)


FailureDomain._set_binding_type(type.StructType(
    'com.vmware.nsx.model.failure_domain', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'preferred_active_edge_services': type.OptionalType(type.BooleanType()),
    },
    FailureDomain,
    False,
    None))



class FailureDomainListResult(VapiStruct):
    """
    It will have list of failure domains which also includes system generated
    failure domain.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`FailureDomain` or ``None``
        :param results: Array of all failure domains including system generated default
            failure domain
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


FailureDomainListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.failure_domain_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'FailureDomain'))),
    },
    FailureDomainListResult,
    False,
    None))



class FeaturePermission(VapiStruct):
    """
    Feature Permission

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    PERMISSION_CRUD = "crud"
    """


    """
    PERMISSION_READ = "read"
    """


    """
    PERMISSION_EXECUTE = "execute"
    """


    """
    PERMISSION_NONE = "none"
    """


    """



    _canonical_to_pep_names = {
                            'feature': 'feature',
                            'feature_description': 'feature_description',
                            'feature_name': 'feature_name',
                            'is_execute_recommended': 'is_execute_recommended',
                            'is_internal': 'is_internal',
                            'permission': 'permission',
                            }

    def __init__(self,
                 feature=None,
                 feature_description=None,
                 feature_name=None,
                 is_execute_recommended=None,
                 is_internal=None,
                 permission=None,
                ):
        """
        :type  feature: :class:`str` or ``None``
        :param feature: Feature Id
        :type  feature_description: :class:`str` or ``None``
        :param feature_description: Feature Description
        :type  feature_name: :class:`str` or ``None``
        :param feature_name: Feature Name
        :type  is_execute_recommended: :class:`bool` or ``None``
        :param is_execute_recommended: Is execute recommended
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  is_internal: :class:`bool` or ``None``
        :param is_internal: Is internal
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  permission: :class:`str` or ``None``
        :param permission: Possible values are: 
            
            * :attr:`FeaturePermission.PERMISSION_CRUD`
            * :attr:`FeaturePermission.PERMISSION_READ`
            * :attr:`FeaturePermission.PERMISSION_EXECUTE`
            * :attr:`FeaturePermission.PERMISSION_NONE`
            
             Permission
        """
        self.feature = feature
        self.feature_description = feature_description
        self.feature_name = feature_name
        self.is_execute_recommended = is_execute_recommended
        self.is_internal = is_internal
        self.permission = permission
        VapiStruct.__init__(self)


FeaturePermission._set_binding_type(type.StructType(
    'com.vmware.nsx.model.feature_permission', {
        'feature': type.OptionalType(type.StringType()),
        'feature_description': type.OptionalType(type.StringType()),
        'feature_name': type.OptionalType(type.StringType()),
        'is_execute_recommended': type.OptionalType(type.BooleanType()),
        'is_internal': type.OptionalType(type.BooleanType()),
        'permission': type.OptionalType(type.StringType()),
    },
    FeaturePermission,
    False,
    None))



class FeatureStackCollectionConfiguration(VapiStruct):
    """
    HPM feature stack data collection frequency configuration

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'client_type_collection_configurations': 'client_type_collection_configurations',
                            'feature_stack_name': 'feature_stack_name',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 client_type_collection_configurations=None,
                 feature_stack_name=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  client_type_collection_configurations: :class:`list` of :class:`ClientTypeCollectionConfiguration` or ``None``
        :param client_type_collection_configurations: The set of client type data collection configurations
        :type  feature_stack_name: :class:`str` or ``None``
        :param feature_stack_name: The name of the feature stack
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.client_type_collection_configurations = client_type_collection_configurations
        self.feature_stack_name = feature_stack_name
        VapiStruct.__init__(self)


FeatureStackCollectionConfiguration._set_binding_type(type.StructType(
    'com.vmware.nsx.model.feature_stack_collection_configuration', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'client_type_collection_configurations': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ClientTypeCollectionConfiguration'))),
        'feature_stack_name': type.OptionalType(type.StringType()),
    },
    FeatureStackCollectionConfiguration,
    False,
    None))



class FeatureStackCollectionConfigurationList(VapiStruct):
    """
    Feature stack collection configuration list result

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'results': 'results',
                            }

    def __init__(self,
                 results=None,
                ):
        """
        :type  results: :class:`list` of :class:`FeatureStackCollectionConfiguration` or ``None``
        :param results: The complete set of feature stack data collection configurations
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.results = results
        VapiStruct.__init__(self)


FeatureStackCollectionConfigurationList._set_binding_type(type.StructType(
    'com.vmware.nsx.model.feature_stack_collection_configuration_list', {
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'FeatureStackCollectionConfiguration'))),
    },
    FeatureStackCollectionConfigurationList,
    False,
    None))



class FeatureUsage(VapiStruct):
    """
    feature usage result item

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'capacity_usage': 'capacity_usage',
                            'feature': 'feature',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 capacity_usage=None,
                 feature=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  capacity_usage: :class:`list` of :class:`CapacityUsage` or ``None``
        :param capacity_usage: Capacity Usage List
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  feature: :class:`str` or ``None``
        :param feature: name of the feature
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.capacity_usage = capacity_usage
        self.feature = feature
        VapiStruct.__init__(self)


FeatureUsage._set_binding_type(type.StructType(
    'com.vmware.nsx.model.feature_usage', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'capacity_usage': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'CapacityUsage'))),
        'feature': type.OptionalType(type.StringType()),
    },
    FeatureUsage,
    False,
    None))



class FeatureUsageCsvRecord(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'ccu_usage_count': 'ccu_usage_count',
                            'core_usage_count': 'core_usage_count',
                            'cpu_usage_count': 'cpu_usage_count',
                            'feature': 'feature',
                            'vcpu_usage_count': 'vcpu_usage_count',
                            'vm_usage_count': 'vm_usage_count',
                            }

    def __init__(self,
                 ccu_usage_count=None,
                 core_usage_count=None,
                 cpu_usage_count=None,
                 feature=None,
                 vcpu_usage_count=None,
                 vm_usage_count=None,
                ):
        """
        :type  ccu_usage_count: :class:`long` or ``None``
        :param ccu_usage_count: count of number of concurrent users format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  core_usage_count: :class:`long` or ``None``
        :param core_usage_count: Number of CPU cores used by this feature format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  cpu_usage_count: :class:`long` or ``None``
        :param cpu_usage_count: count of number of cpu sockets used by this feature format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  feature: :class:`str` or ``None``
        :param feature: name of the feature
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  vcpu_usage_count: :class:`long` or ``None``
        :param vcpu_usage_count: count of number of vcpus of public cloud VMs format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  vm_usage_count: :class:`long` or ``None``
        :param vm_usage_count: count of number of vms used by this feature format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.ccu_usage_count = ccu_usage_count
        self.core_usage_count = core_usage_count
        self.cpu_usage_count = cpu_usage_count
        self.feature = feature
        self.vcpu_usage_count = vcpu_usage_count
        self.vm_usage_count = vm_usage_count
        VapiStruct.__init__(self)


FeatureUsageCsvRecord._set_binding_type(type.StructType(
    'com.vmware.nsx.model.feature_usage_csv_record', {
        'ccu_usage_count': type.OptionalType(type.IntegerType()),
        'core_usage_count': type.OptionalType(type.IntegerType()),
        'cpu_usage_count': type.OptionalType(type.IntegerType()),
        'feature': type.OptionalType(type.StringType()),
        'vcpu_usage_count': type.OptionalType(type.IntegerType()),
        'vm_usage_count': type.OptionalType(type.IntegerType()),
    },
    FeatureUsageCsvRecord,
    False,
    None))



class FeatureUsageList(VapiStruct):
    """
    list of feature usage items

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'feature_usage_info': 'feature_usage_info',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 feature_usage_info=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  feature_usage_info: :class:`list` of :class:`FeatureUsage` or ``None``
        :param feature_usage_info: Feature Usage List
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.feature_usage_info = feature_usage_info
        VapiStruct.__init__(self)


FeatureUsageList._set_binding_type(type.StructType(
    'com.vmware.nsx.model.feature_usage_list', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'feature_usage_info': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'FeatureUsage'))),
    },
    FeatureUsageList,
    False,
    None))



class FeatureUsageListInCsvFormat(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'file_name': 'file_name',
                            'last_update_timestamp': 'last_update_timestamp',
                            'results': 'results',
                            }

    def __init__(self,
                 file_name=None,
                 last_update_timestamp=None,
                 results=None,
                ):
        """
        :type  file_name: :class:`str` or ``None``
        :param file_name: File name set by HTTP server if API returns CSV result as a file.
        :type  last_update_timestamp: :class:`long` or ``None``
        :param last_update_timestamp: Timestamp when the data was last updated; unset if data source has
            never updated the data. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`FeatureUsageCsvRecord` or ``None``
        :param results: 
        """
        self.file_name = file_name
        self.last_update_timestamp = last_update_timestamp
        self.results = results
        VapiStruct.__init__(self)


FeatureUsageListInCsvFormat._set_binding_type(type.StructType(
    'com.vmware.nsx.model.feature_usage_list_in_csv_format', {
        'file_name': type.OptionalType(type.StringType()),
        'last_update_timestamp': type.OptionalType(type.IntegerType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'FeatureUsageCsvRecord'))),
    },
    FeatureUsageListInCsvFormat,
    False,
    None))



class FieldsPacketData(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "FieldsPacketData"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'arp_header': 'arp_header',
                            'eth_header': 'eth_header',
                            'ip_header': 'ip_header',
                            'ipv6_header': 'ipv6_header',
                            'payload': 'payload',
                            'transport_header': 'transport_header',
                            'frame_size': 'frame_size',
                            'resource_type': 'resource_type',
                            'routed': 'routed',
                            'transport_type': 'transport_type',
                            }

    def __init__(self,
                 arp_header=None,
                 eth_header=None,
                 ip_header=None,
                 ipv6_header=None,
                 payload=None,
                 transport_header=None,
                 frame_size=None,
                 resource_type='FieldsPacketData',
                 routed=None,
                 transport_type=None,
                ):
        """
        :type  arp_header: :class:`ArpHeader` or ``None``
        :param arp_header: The ARP header
        :type  eth_header: :class:`EthernetHeader` or ``None``
        :param eth_header: The ethernet header
        :type  ip_header: :class:`Ipv4Header` or ``None``
        :param ip_header: The IPv4 header
        :type  ipv6_header: :class:`Ipv6Header` or ``None``
        :param ipv6_header: The IPv6 header
        :type  payload: :class:`str` or ``None``
        :param payload: Up to 1000 bytes of payload may be supplied (with a base64-encoded
            length of 1336 bytes.) Additional bytes of traceflow metadata will
            be appended to the payload. The payload contains any data the user
            wants to put after the transport header.
        :type  transport_header: :class:`TransportProtocolHeader` or ``None``
        :param transport_header: This field contains a protocol that is above IP. It is not
            restricted to the 'transport' defined by the OSI model (e.g., ICMP
            is supported).
        :type  frame_size: :class:`long` or ``None``
        :param frame_size: If the requested frame_size is too small (given the payload and
            traceflow metadata requirement of 16 bytes), the traceflow request
            will fail with an appropriate message. The frame will be zero
            padded to the requested size. format: int64
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`PacketData.RESOURCE_TYPE_BINARYPACKETDATA`
            * :attr:`PacketData.RESOURCE_TYPE_FIELDSPACKETDATA`
            
             Packet configuration
        :type  routed: :class:`bool` or ``None``
        :param routed: A flag, when set true, indicates that the traceflow packet is of L3
            routing.
        :type  transport_type: :class:`str` or ``None``
        :param transport_type: Possible values are: 
            
            * :attr:`PacketData.TRANSPORT_TYPE_BROADCAST`
            * :attr:`PacketData.TRANSPORT_TYPE_UNICAST`
            * :attr:`PacketData.TRANSPORT_TYPE_MULTICAST`
            * :attr:`PacketData.TRANSPORT_TYPE_UNKNOWN`
            
             transport type of the traceflow packet
        """
        self.arp_header = arp_header
        self.eth_header = eth_header
        self.ip_header = ip_header
        self.ipv6_header = ipv6_header
        self.payload = payload
        self.transport_header = transport_header
        self.frame_size = frame_size
        self._resource_type = resource_type
        self.routed = routed
        self.transport_type = transport_type
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

FieldsPacketData._set_binding_type(type.StructType(
    'com.vmware.nsx.model.fields_packet_data', {
        'arp_header': type.OptionalType(type.ReferenceType(__name__, 'ArpHeader')),
        'eth_header': type.OptionalType(type.ReferenceType(__name__, 'EthernetHeader')),
        'ip_header': type.OptionalType(type.ReferenceType(__name__, 'Ipv4Header')),
        'ipv6_header': type.OptionalType(type.ReferenceType(__name__, 'Ipv6Header')),
        'payload': type.OptionalType(type.StringType()),
        'transport_header': type.OptionalType(type.ReferenceType(__name__, 'TransportProtocolHeader')),
        'frame_size': type.OptionalType(type.IntegerType()),
        'resource_type': type.StringType(),
        'routed': type.OptionalType(type.BooleanType()),
        'transport_type': type.OptionalType(type.StringType()),
    },
    FieldsPacketData,
    False,
    None))



class FileProperties(VapiStruct):
    """
    File properties

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'created_epoch_ms': 'created_epoch_ms',
                            'modified_epoch_ms': 'modified_epoch_ms',
                            'name': 'name',
                            'size': 'size',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 created_epoch_ms=None,
                 modified_epoch_ms=None,
                 name=None,
                 size=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  created_epoch_ms: :class:`long` or ``None``
        :param created_epoch_ms: File creation time in epoch milliseconds format: int64
        :type  modified_epoch_ms: :class:`long` or ``None``
        :param modified_epoch_ms: File modification time in epoch milliseconds format: int64
        :type  name: :class:`str` or ``None``
        :param name: File name
        :type  size: :class:`long` or ``None``
        :param size: Size of the file in bytes format: int64
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.created_epoch_ms = created_epoch_ms
        self.modified_epoch_ms = modified_epoch_ms
        self.name = name
        self.size = size
        VapiStruct.__init__(self)


FileProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.file_properties', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'created_epoch_ms': type.OptionalType(type.IntegerType()),
        'modified_epoch_ms': type.OptionalType(type.IntegerType()),
        'name': type.OptionalType(type.StringType()),
        'size': type.OptionalType(type.IntegerType()),
    },
    FileProperties,
    False,
    None))



class FilePropertiesListResult(VapiStruct):
    """
    File properties query results

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`FileProperties` or ``None``
        :param results: File property results
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


FilePropertiesListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.file_properties_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'FileProperties'))),
    },
    FilePropertiesListResult,
    False,
    None))



class FileThumbprint(VapiStruct):
    """
    File thumbprint

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'name': 'name',
                            'sha1': 'sha1',
                            'sha256': 'sha256',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 name=None,
                 sha1=None,
                 sha256=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  name: :class:`str` or ``None``
        :param name: File name
        :type  sha1: :class:`str` or ``None``
        :param sha1: File's SHA1 thumbprint
        :type  sha256: :class:`str` or ``None``
        :param sha256: File's SHA256 thumbprint
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.name = name
        self.sha1 = sha1
        self.sha256 = sha256
        VapiStruct.__init__(self)


FileThumbprint._set_binding_type(type.StructType(
    'com.vmware.nsx.model.file_thumbprint', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'name': type.OptionalType(type.StringType()),
        'sha1': type.OptionalType(type.StringType()),
        'sha256': type.OptionalType(type.StringType()),
    },
    FileThumbprint,
    False,
    None))



class FileTransferAuthenticationScheme(VapiStruct):
    """
    Remote server authentication details

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    SCHEME_NAME_PASSWORD = "PASSWORD"
    """


    """



    _canonical_to_pep_names = {
                            'password': 'password',
                            'scheme_name': 'scheme_name',
                            'username': 'username',
                            }

    def __init__(self,
                 password=None,
                 scheme_name=None,
                 username=None,
                ):
        """
        :type  password: :class:`str` or ``None``
        :param password: Password to authenticate with
        :type  scheme_name: :class:`str` or ``None``
        :param scheme_name: Possible values are: 
            
            * :attr:`FileTransferAuthenticationScheme.SCHEME_NAME_PASSWORD`
            
             Authentication scheme name
        :type  username: :class:`str` or ``None``
        :param username: User name to authenticate with
        """
        self.password = password
        self.scheme_name = scheme_name
        self.username = username
        VapiStruct.__init__(self)


FileTransferAuthenticationScheme._set_binding_type(type.StructType(
    'com.vmware.nsx.model.file_transfer_authentication_scheme', {
        'password': type.OptionalType(type.StringType()),
        'scheme_name': type.OptionalType(type.StringType()),
        'username': type.OptionalType(type.StringType()),
    },
    FileTransferAuthenticationScheme,
    False,
    None))



class FileTransferProtocol(VapiStruct):
    """
    Protocol to transfer backup file to remote server

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    PROTOCOL_NAME_SFTP = "sftp"
    """


    """



    _canonical_to_pep_names = {
                            'authentication_scheme': 'authentication_scheme',
                            'protocol_name': 'protocol_name',
                            'ssh_fingerprint': 'ssh_fingerprint',
                            }

    def __init__(self,
                 authentication_scheme=None,
                 protocol_name=None,
                 ssh_fingerprint=None,
                ):
        """
        :type  authentication_scheme: :class:`FileTransferAuthenticationScheme` or ``None``
        :param authentication_scheme: Scheme to authenticate if required
        :type  protocol_name: :class:`str` or ``None``
        :param protocol_name: Possible values are: 
            
            * :attr:`FileTransferProtocol.PROTOCOL_NAME_SFTP`
            
             Protocol name
        :type  ssh_fingerprint: :class:`str` or ``None``
        :param ssh_fingerprint: The expected SSH fingerprint of the server. If the server's
            fingerprint does not match this fingerprint, the connection will be
            terminated. Only ECDSA fingerprints hashed with SHA256 are
            supported. To obtain the host's ssh fingerprint, you should connect
            via some method other than SSH to obtain this information. You can
            use one of these commands to view the key's fingerprint: 1.
            ssh-keygen -l -E sha256 -f ssh_host_ecdsa_key.pub 2. awk '{print
            $2}' ssh_host_ecdsa_key.pub | base64 -d | sha256sum -b | sed 's/
            .\*$//' | xxd -r -p | base64 | sed 's/.//44g' | awk '{print
            \"SHA256:\"$1}'
        """
        self.authentication_scheme = authentication_scheme
        self.protocol_name = protocol_name
        self.ssh_fingerprint = ssh_fingerprint
        VapiStruct.__init__(self)


FileTransferProtocol._set_binding_type(type.StructType(
    'com.vmware.nsx.model.file_transfer_protocol', {
        'authentication_scheme': type.OptionalType(type.ReferenceType(__name__, 'FileTransferAuthenticationScheme')),
        'protocol_name': type.OptionalType(type.StringType()),
        'ssh_fingerprint': type.OptionalType(type.StringType()),
    },
    FileTransferProtocol,
    False,
    None))



class Filter(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'name': 'name',
                            'value': 'value',
                            }

    def __init__(self,
                 name=None,
                 value=None,
                ):
        """
        :type  name: :class:`str` or ``None``
        :param name: The name of the filter.
        :type  value: :class:`str` or ``None``
        :param value: The value of the filter.
        """
        self.name = name
        self.value = value
        VapiStruct.__init__(self)


Filter._set_binding_type(type.StructType(
    'com.vmware.nsx.model.filter', {
        'name': type.OptionalType(type.StringType()),
        'value': type.OptionalType(type.StringType()),
    },
    Filter,
    False,
    None))



class FilterRequest(VapiStruct):
    """
    Filter request parameters

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'field_names': 'field_names',
                            'value': 'value',
                            }

    def __init__(self,
                 field_names=None,
                 value=None,
                ):
        """
        :type  field_names: :class:`str` or ``None``
        :param field_names: Comma seperated fields to be filtered on
        :type  value: :class:`str` or ``None``
        :param value: Filter value
        """
        self.field_names = field_names
        self.value = value
        VapiStruct.__init__(self)


FilterRequest._set_binding_type(type.StructType(
    'com.vmware.nsx.model.filter_request', {
        'field_names': type.OptionalType(type.StringType()),
        'value': type.OptionalType(type.StringType()),
    },
    FilterRequest,
    False,
    None))



class FilterWidgetConfiguration(VapiStruct):
    """
    Represents configuration for filter widget. This is abstract representation
    of filter widget.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "FilterWidgetConfiguration"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'alias': 'alias',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'datasources': 'datasources',
                            'default_filter_value': 'default_filter_value',
                            'drilldown_id': 'drilldown_id',
                            'filter': 'filter',
                            'filter_value_required': 'filter_value_required',
                            'footer': 'footer',
                            'icons': 'icons',
                            'is_drilldown': 'is_drilldown',
                            'legend': 'legend',
                            'shared': 'shared',
                            'span': 'span',
                            'weight': 'weight',
                            }

    def __init__(self,
                 alias=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='FilterWidgetConfiguration',
                 tags=None,
                 datasources=None,
                 default_filter_value=None,
                 drilldown_id=None,
                 filter=None,
                 filter_value_required=None,
                 footer=None,
                 icons=None,
                 is_drilldown=None,
                 legend=None,
                 shared=None,
                 span=None,
                 weight=None,
                ):
        """
        :type  alias: :class:`str` or ``None``
        :param alias: Alias to be used when emitting filter value.
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Title of the widget. If display_name is omitted, the widget will be
            shown without a title.
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_LABELVALUECONFIGURATION`
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_DONUTCONFIGURATION`
            *
              :attr:`WidgetConfiguration.RESOURCE_TYPE_MULTIWIDGETCONFIGURATION`
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_CONTAINERCONFIGURATION`
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_STATSCONFIGURATION`
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_GRIDCONFIGURATION`
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_GRAPHCONFIGURATION`
            *
              :attr:`WidgetConfiguration.RESOURCE_TYPE_CUSTOMWIDGETCONFIGURATION`
            *
              :attr:`WidgetConfiguration.RESOURCE_TYPE_DROPDOWNFILTERWIDGETCONFIGURATION`
            
            Supported visualization types are LabelValueConfiguration,
            DonutConfiguration, GridConfiguration, StatsConfiguration,
            MultiWidgetConfiguration, GraphConfiguration,
            ContainerConfiguration, CustomWidgetConfiguration and
            DropdownFilterWidgetConfiguration.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  datasources: :class:`list` of :class:`Datasource` or ``None``
        :param datasources: The 'datasources' represent the sources from which data will be
            fetched. Currently, only NSX-API is supported as a 'default'
            datasource. An example of specifying 'default' datasource along
            with the urls to fetch data from is given at 'example_request'
            section of 'CreateWidgetConfiguration' API.
        :type  default_filter_value: :class:`list` of :class:`DefaultFilterValue` or ``None``
        :param default_filter_value: Default filter values to be passed to datasources. This will be
            used when the report is requested without filter values.
        :type  drilldown_id: :class:`str` or ``None``
        :param drilldown_id: Id of drilldown widget, if any. Id should be a valid id of an
            existing widget. A widget is considered as drilldown widget when it
            is associated with any other widget and provides more detailed
            information about any data item from the parent widget.
        :type  filter: :class:`str` or ``None``
        :param filter: Id of filter widget for subscription, if any. Id should be a valid
            id of an existing filter widget. Filter widget should be from the
            same view. Datasource URLs should have placeholder values equal to
            filter alias to accept the filter value on filter change.
        :type  filter_value_required: :class:`bool` or ``None``
        :param filter_value_required: Flag to indicate that widget will continue to work without filter
            value. If this flag is set to false then default_filter_value is
            manadatory.
        :type  footer: :class:`Footer` or ``None``
        :param footer: 
        :type  icons: :class:`list` of :class:`Icon` or ``None``
        :param icons: Icons to be applied at dashboard for widgets and UI elements.
        :type  is_drilldown: :class:`bool` or ``None``
        :param is_drilldown: Set to true if this widget should be used as a drilldown.
        :type  legend: :class:`Legend` or ``None``
        :param legend: Legend to be displayed. If legend is not needed, do not include it.
        :type  shared: :class:`bool` or ``None``
        :param shared: Please use the property 'shared' of View instead of this. The
            widgets of a shared view are visible to other users.
        :type  span: :class:`long` or ``None``
        :param span: Represents the horizontal span of the widget / container. format:
            int32
        :type  weight: :class:`long` or ``None``
        :param weight: Specify relavite weight in WidgetItem for placement in a view.
            Please see WidgetItem for details. format: int32
        """
        self.alias = alias
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        self.datasources = datasources
        self.default_filter_value = default_filter_value
        self.drilldown_id = drilldown_id
        self.filter = filter
        self.filter_value_required = filter_value_required
        self.footer = footer
        self.icons = icons
        self.is_drilldown = is_drilldown
        self.legend = legend
        self.shared = shared
        self.span = span
        self.weight = weight
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

FilterWidgetConfiguration._set_binding_type(type.StructType(
    'com.vmware.nsx.model.filter_widget_configuration', {
        'alias': type.OptionalType(type.StringType()),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'datasources': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Datasource'))),
        'default_filter_value': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'DefaultFilterValue'))),
        'drilldown_id': type.OptionalType(type.StringType()),
        'filter': type.OptionalType(type.StringType()),
        'filter_value_required': type.OptionalType(type.BooleanType()),
        'footer': type.OptionalType(type.ReferenceType(__name__, 'Footer')),
        'icons': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Icon'))),
        'is_drilldown': type.OptionalType(type.BooleanType()),
        'legend': type.OptionalType(type.ReferenceType(__name__, 'Legend')),
        'shared': type.OptionalType(type.BooleanType()),
        'span': type.OptionalType(type.IntegerType()),
        'weight': type.OptionalType(type.IntegerType()),
    },
    FilterWidgetConfiguration,
    False,
    None))



class FipsGlobalConfig(VapiStruct):
    """
    Policy api will overwrite the fipsGlobalConfig set using MP api. Always use
    https://<policyIp>/policy/api/v1/infra/global-config to update fips
    configuration.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "FipsGlobalConfig"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'lb_fips_enabled': 'lb_fips_enabled',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            }

    def __init__(self,
                 lb_fips_enabled=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='FipsGlobalConfig',
                 tags=None,
                ):
        """
        :type  lb_fips_enabled: :class:`bool` or ``None``
        :param lb_fips_enabled: When this flag is set to true FIPS mode will be set on ssl
            encryptions of load balancer feature.
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`GlobalConfigs.RESOURCE_TYPE_SWITCHINGGLOBALCONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_ROUTINGGLOBALCONFIG`
            *
              :attr:`GlobalConfigs.RESOURCE_TYPE_OPERATIONCOLLECTORGLOBALCONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_FIREWALLGLOBALCONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_ESXGLOBALOPAQUECONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_SECURITYGLOBALCONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_FIPSGLOBALCONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_FEDERATIONGLOBALCONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_IDSGLOBALCONFIG`
            
             Valid Global configuration types
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        """
        self.lb_fips_enabled = lb_fips_enabled
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

FipsGlobalConfig._set_binding_type(type.StructType(
    'com.vmware.nsx.model.fips_global_config', {
        'lb_fips_enabled': type.OptionalType(type.BooleanType()),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
    },
    FipsGlobalConfig,
    False,
    None))



class FireWallServiceAssociationListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "FireWallServiceAssociationListResult"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'results': 'results',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'service_type': 'service_type',
                            }

    def __init__(self,
                 results=None,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 service_type='FireWallServiceAssociationListResult',
                ):
        """
        :type  results: :class:`list` of :class:`FirewallRule` or ``None``
        :param results: Firewall rule list result with pagination support.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  service_type: :class:`str`
        :param service_type: Possible values are: 
            
            *
              :attr:`ServiceAssociationListResult.SERVICE_TYPE_FIREWALLSERVICEASSOCIATIONLISTRESULT`
            *
              :attr:`ServiceAssociationListResult.SERVICE_TYPE_IPFIXSERVICEASSOCIATIONLISTRESULT`
        """
        self.results = results
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self._service_type = service_type
        VapiStruct.__init__(self)

    @property
    def service_type(self):
        """
        Return the discriminator value
        """
        return self._service_type

FireWallServiceAssociationListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.fire_wall_service_association_list_result', {
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'FirewallRule'))),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'service_type': type.StringType(),
    },
    FireWallServiceAssociationListResult,
    False,
    None))



class FirewallCpuMemThresholdsProfile(VapiStruct):
    """
    A profile holding CPU and memory threshold configuration.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "FirewallCpuMemThresholdsProfile"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'cpu_threshold_percentage': 'cpu_threshold_percentage',
                            'mem_threshold_percentage': 'mem_threshold_percentage',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            }

    def __init__(self,
                 cpu_threshold_percentage=None,
                 mem_threshold_percentage=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='FirewallCpuMemThresholdsProfile',
                 tags=None,
                ):
        """
        :type  cpu_threshold_percentage: :class:`long` or ``None``
        :param cpu_threshold_percentage: CPU utilization threshold percentage to monitor and report for
            distributed firewall. format: int64
        :type  mem_threshold_percentage: :class:`long` or ``None``
        :param mem_threshold_percentage: Heap memory threshold percentage to monitor and report for
            distributed firewall. format: int64
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            *
              :attr:`BaseFirewallProfile.RESOURCE_TYPE_FIREWALLSESSIONTIMERPROFILE`
            *
              :attr:`BaseFirewallProfile.RESOURCE_TYPE_FIREWALLCPUMEMTHRESHOLDSPROFILE`
            *
              :attr:`BaseFirewallProfile.RESOURCE_TYPE_FIREWALLFLOODPROTECTIONPROFILE`
            * :attr:`BaseFirewallProfile.RESOURCE_TYPE_FIREWALLDNSPROFILE`
            
             Resource type to use as profile type
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        """
        self.cpu_threshold_percentage = cpu_threshold_percentage
        self.mem_threshold_percentage = mem_threshold_percentage
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

FirewallCpuMemThresholdsProfile._set_binding_type(type.StructType(
    'com.vmware.nsx.model.firewall_cpu_mem_thresholds_profile', {
        'cpu_threshold_percentage': type.OptionalType(type.IntegerType()),
        'mem_threshold_percentage': type.OptionalType(type.IntegerType()),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
    },
    FirewallCpuMemThresholdsProfile,
    False,
    None))



class FirewallDnsProfile(VapiStruct):
    """
    A profile holding DNS configuration which allows firewall to use DNS
    response packets and manage firewall cache. e.g. TTL used to expire snooped
    entries from cache.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "FirewallDnsProfile"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'dns_ttl_config': 'dns_ttl_config',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            }

    def __init__(self,
                 dns_ttl_config=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='FirewallDnsProfile',
                 tags=None,
                ):
        """
        :type  dns_ttl_config: :class:`DnsTtlConfig` or ``None``
        :param dns_ttl_config: Firewall to use TTL config to manage firewall cache to expire
            snooped FQDN entries from DNS response.
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            *
              :attr:`BaseFirewallProfile.RESOURCE_TYPE_FIREWALLSESSIONTIMERPROFILE`
            *
              :attr:`BaseFirewallProfile.RESOURCE_TYPE_FIREWALLCPUMEMTHRESHOLDSPROFILE`
            *
              :attr:`BaseFirewallProfile.RESOURCE_TYPE_FIREWALLFLOODPROTECTIONPROFILE`
            * :attr:`BaseFirewallProfile.RESOURCE_TYPE_FIREWALLDNSPROFILE`
            
             Resource type to use as profile type
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        """
        self.dns_ttl_config = dns_ttl_config
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

FirewallDnsProfile._set_binding_type(type.StructType(
    'com.vmware.nsx.model.firewall_dns_profile', {
        'dns_ttl_config': type.OptionalType(type.ReferenceType(__name__, 'DnsTtlConfig')),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
    },
    FirewallDnsProfile,
    False,
    None))



class FirewallFloodProtectionProfile(VapiStruct):
    """
    A profile holding protection configuration for SYN flood, UDP flood, ICMP
    flood and other flood attack.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "FirewallFloodProtectionProfile"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'enable_rst_spoofing': 'enable_rst_spoofing',
                            'enable_syncache': 'enable_syncache',
                            'icmp_active_flow_limit': 'icmp_active_flow_limit',
                            'other_active_conn_limit': 'other_active_conn_limit',
                            'tcp_half_open_conn_limit': 'tcp_half_open_conn_limit',
                            'udp_active_flow_limit': 'udp_active_flow_limit',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            }

    def __init__(self,
                 enable_rst_spoofing=None,
                 enable_syncache=None,
                 icmp_active_flow_limit=None,
                 other_active_conn_limit=None,
                 tcp_half_open_conn_limit=None,
                 udp_active_flow_limit=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='FirewallFloodProtectionProfile',
                 tags=None,
                ):
        """
        :type  enable_rst_spoofing: :class:`bool` or ``None``
        :param enable_rst_spoofing: The flag to indicate RST spoofing is enabled or not. This option
            does not apply to EDGE components. This can be enabled only if
            syncache is enabled.
        :type  enable_syncache: :class:`bool` or ``None``
        :param enable_syncache: The flag to indicate syncache is enabled or not. This option does
            not apply to EDGE components.
        :type  icmp_active_flow_limit: :class:`long` or ``None``
        :param icmp_active_flow_limit: The maximum limit of active icmp connections. If this property is
            omitted, or set to null, then there is no limit on active icmp
            connections for those components if it's applied to ESX components
            (such as segment, segment port, virtual machine, etc); on the other
            side, if it's applied to EDGE components (such as, gateway), it
            will be set to default limit (10,000) on the specific components.
            format: int64
        :type  other_active_conn_limit: :class:`long` or ``None``
        :param other_active_conn_limit: The maximum limit of other active connections besides udp, icmp and
            half open tcp connections. If this property is omitted, or set to
            null, then there is no limit on other active connections besides
            udp, icmp and tcp half open connections for those components if
            it's applied to ESX components (such as segment, segment port,
            virtual machine, etc); on the other side, if it's applied to EDGE
            components (such as, gateway), it will be set to default limit
            (10,000) on the specific components. format: int64
        :type  tcp_half_open_conn_limit: :class:`long` or ``None``
        :param tcp_half_open_conn_limit: The maximum limit of tcp half open connections. If this property is
            omitted, or set to null, then there is no limit on active tcp half
            open connections for those components if it's applied to ESX
            components (such as segment, segment port, virtual machine, etc);
            on the other side, if it's applied to EDGE components (such as,
            gateway), it will be set to default limit (1,000,000) on the
            specific components. format: int64
        :type  udp_active_flow_limit: :class:`long` or ``None``
        :param udp_active_flow_limit: The maximum limit of active udp connections. If this property is
            omitted, or set to null, then there is no limit on active udp
            connections for those components if it's applied to ESX components
            (such as segment, segment port, virtual machine, etc); on the other
            side, if it's applied to EDGE components (such as, gateway), it
            will be set to default limit (100,000) on the specific component.
            format: int64
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            *
              :attr:`BaseFirewallProfile.RESOURCE_TYPE_FIREWALLSESSIONTIMERPROFILE`
            *
              :attr:`BaseFirewallProfile.RESOURCE_TYPE_FIREWALLCPUMEMTHRESHOLDSPROFILE`
            *
              :attr:`BaseFirewallProfile.RESOURCE_TYPE_FIREWALLFLOODPROTECTIONPROFILE`
            * :attr:`BaseFirewallProfile.RESOURCE_TYPE_FIREWALLDNSPROFILE`
            
             Resource type to use as profile type
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        """
        self.enable_rst_spoofing = enable_rst_spoofing
        self.enable_syncache = enable_syncache
        self.icmp_active_flow_limit = icmp_active_flow_limit
        self.other_active_conn_limit = other_active_conn_limit
        self.tcp_half_open_conn_limit = tcp_half_open_conn_limit
        self.udp_active_flow_limit = udp_active_flow_limit
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

FirewallFloodProtectionProfile._set_binding_type(type.StructType(
    'com.vmware.nsx.model.firewall_flood_protection_profile', {
        'enable_rst_spoofing': type.OptionalType(type.BooleanType()),
        'enable_syncache': type.OptionalType(type.BooleanType()),
        'icmp_active_flow_limit': type.OptionalType(type.IntegerType()),
        'other_active_conn_limit': type.OptionalType(type.IntegerType()),
        'tcp_half_open_conn_limit': type.OptionalType(type.IntegerType()),
        'udp_active_flow_limit': type.OptionalType(type.IntegerType()),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
    },
    FirewallFloodProtectionProfile,
    False,
    None))



class FirewallGlobalConfig(VapiStruct):
    """
    NSX global configs for Distributed Firewall

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "FirewallGlobalConfig"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'global_addrset_mode_enabled': 'global_addrset_mode_enabled',
                            'global_fastpath_mode_enabled': 'global_fastpath_mode_enabled',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            }

    def __init__(self,
                 global_addrset_mode_enabled=None,
                 global_fastpath_mode_enabled=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='FirewallGlobalConfig',
                 tags=None,
                ):
        """
        :type  global_addrset_mode_enabled: :class:`bool` or ``None``
        :param global_addrset_mode_enabled: When this flag is set to true, global address set is enabled in
            Distributed Firewall.
        :type  global_fastpath_mode_enabled: :class:`bool` or ``None``
        :param global_fastpath_mode_enabled: This property is deprecated. The fast path mode is always enabled
            in Distributed Firewall.
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`GlobalConfigs.RESOURCE_TYPE_SWITCHINGGLOBALCONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_ROUTINGGLOBALCONFIG`
            *
              :attr:`GlobalConfigs.RESOURCE_TYPE_OPERATIONCOLLECTORGLOBALCONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_FIREWALLGLOBALCONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_ESXGLOBALOPAQUECONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_SECURITYGLOBALCONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_FIPSGLOBALCONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_FEDERATIONGLOBALCONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_IDSGLOBALCONFIG`
            
             Valid Global configuration types
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        """
        self.global_addrset_mode_enabled = global_addrset_mode_enabled
        self.global_fastpath_mode_enabled = global_fastpath_mode_enabled
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

FirewallGlobalConfig._set_binding_type(type.StructType(
    'com.vmware.nsx.model.firewall_global_config', {
        'global_addrset_mode_enabled': type.OptionalType(type.BooleanType()),
        'global_fastpath_mode_enabled': type.OptionalType(type.BooleanType()),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
    },
    FirewallGlobalConfig,
    False,
    None))



class FirewallProfileListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param results: List of firewall profiles.
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`BaseFirewallProfile`. When methods return a value of this
            class as a return value, the attribute will contain all the
            attributes defined in :class:`BaseFirewallProfile`.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


FirewallProfileListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.firewall_profile_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'BaseFirewallProfile')]))),
    },
    FirewallProfileListResult,
    False,
    None))



class FirewallRule(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    ACTION_ALLOW = "ALLOW"
    """


    """
    ACTION_DROP = "DROP"
    """


    """
    ACTION_REJECT = "REJECT"
    """


    """
    ACTION_REDIRECT = "REDIRECT"
    """


    """
    ACTION_DO_NOT_REDIRECT = "DO_NOT_REDIRECT"
    """


    """
    ACTION_DETECT = "DETECT"
    """


    """
    DIRECTION_IN = "IN"
    """


    """
    DIRECTION_OUT = "OUT"
    """


    """
    DIRECTION_IN_OUT = "IN_OUT"
    """


    """
    IP_PROTOCOL_IPV4 = "IPV4"
    """


    """
    IP_PROTOCOL_IPV6 = "IPV6"
    """


    """
    IP_PROTOCOL_IPV4_IPV6 = "IPV4_IPV6"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_owner': 'owner',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'action': 'action',
                            'applied_tos': 'applied_tos',
                            'destinations': 'destinations',
                            'destinations_excluded': 'destinations_excluded',
                            'direction': 'direction',
                            'disabled': 'disabled',
                            'ip_protocol': 'ip_protocol',
                            'is_default': 'is_default',
                            'logged': 'logged',
                            'notes': 'notes',
                            'priority': 'priority',
                            'rule_tag': 'rule_tag',
                            'sources': 'sources',
                            'sources_excluded': 'sources_excluded',
                            'context_profiles': 'context_profiles',
                            'extended_sources': 'extended_sources',
                            'section_id': 'section_id',
                            'services': 'services',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 owner=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 action=None,
                 applied_tos=None,
                 destinations=None,
                 destinations_excluded=None,
                 direction=None,
                 disabled=None,
                 ip_protocol=None,
                 is_default=None,
                 logged=None,
                 notes=None,
                 priority=None,
                 rule_tag=None,
                 sources=None,
                 sources_excluded=None,
                 context_profiles=None,
                 extended_sources=None,
                 section_id=None,
                 services=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  owner: :class:`OwnerResourceLink` or ``None``
        :param owner: Owner of this resource
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Identifier of the resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  action: :class:`str` or ``None``
        :param action: Possible values are: 
            
            * :attr:`FirewallRule.ACTION_ALLOW`
            * :attr:`FirewallRule.ACTION_DROP`
            * :attr:`FirewallRule.ACTION_REJECT`
            * :attr:`FirewallRule.ACTION_REDIRECT`
            * :attr:`FirewallRule.ACTION_DO_NOT_REDIRECT`
            * :attr:`FirewallRule.ACTION_DETECT`
            
            Action enforced on the packets which matches the distributed
            service rule. Currently DS Layer supports below actions. ALLOW -
            Forward any packet when a rule with this action gets a match (Used
            by Firewall). DROP - Drop any packet when a rule with this action
            gets a match. Packets won't go further(Used by Firewall). REJECT -
            Terminate TCP connection by sending TCP reset for a packet when a
            rule with this action gets a match (Used by Firewall). REDIRECT -
            Redirect any packet to a partner appliance when a rule with this
            action gets a match (Used by Service Insertion). DO_NOT_REDIRECT -
            Do not redirect any packet to a partner appliance when a rule with
            this action gets a match (Used by Service Insertion). DETECT -
            Detect IDS Signatures.
        :type  applied_tos: :class:`list` of :class:`ResourceReference` or ``None``
        :param applied_tos: List of object where rule will be enforced. The section level field
            overrides this one. Null will be treated as any.
        :type  destinations: :class:`list` of :class:`ResourceReference` or ``None``
        :param destinations: List of the destinations. Null will be treated as any.
        :type  destinations_excluded: :class:`bool` or ``None``
        :param destinations_excluded: Negation of the destination.
        :type  direction: :class:`str` or ``None``
        :param direction: Possible values are: 
            
            * :attr:`FirewallRule.DIRECTION_IN`
            * :attr:`FirewallRule.DIRECTION_OUT`
            * :attr:`FirewallRule.DIRECTION_IN_OUT`
            
            Rule direction in case of stateless distributed service rules. This
            will only considered if section level parameter is set to
            stateless. Default to IN_OUT if not specified.
        :type  disabled: :class:`bool` or ``None``
        :param disabled: Flag to disable rule. Disabled will only be persisted but never
            provisioned/realized.
        :type  ip_protocol: :class:`str` or ``None``
        :param ip_protocol: Possible values are: 
            
            * :attr:`FirewallRule.IP_PROTOCOL_IPV4`
            * :attr:`FirewallRule.IP_PROTOCOL_IPV6`
            * :attr:`FirewallRule.IP_PROTOCOL_IPV4_IPV6`
            
             Type of IP packet that should be matched while enforcing the rule.
        :type  is_default: :class:`bool` or ``None``
        :param is_default: Flag to indicate whether rule is default.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  logged: :class:`bool` or ``None``
        :param logged: Flag to enable packet logging. Default is disabled.
        :type  notes: :class:`str` or ``None``
        :param notes: User notes specific to the rule.
        :type  priority: :class:`long` or ``None``
        :param priority: Priority of the rule. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  rule_tag: :class:`str` or ``None``
        :param rule_tag: User level field which will be printed in CLI and packet logs.
        :type  sources: :class:`list` of :class:`ResourceReference` or ``None``
        :param sources: List of sources. Null will be treated as any.
        :type  sources_excluded: :class:`bool` or ``None``
        :param sources_excluded: Negation of the source.
        :type  context_profiles: :class:`list` of :class:`ResourceReference` or ``None``
        :param context_profiles: NS Profile object which accepts attributes and sub-attributes of
            various network services (ex. L7 AppId, domain name, encryption
            algorithm) as key value pairs.
        :type  extended_sources: :class:`list` of :class:`ResourceReference` or ``None``
        :param extended_sources: List of NSGroups that have end point attributes like AD
            Groups(SID), process name, process hash etc. For Flash release,
            only NSGroups containing AD Groups are supported.
        :type  section_id: :class:`str` or ``None``
        :param section_id: Section Id of the section to which this rule belongs to.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  services: :class:`list` of :class:`FirewallService` or ``None``
        :param services: List of the services. Null will be treated as any.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.owner = owner
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.action = action
        self.applied_tos = applied_tos
        self.destinations = destinations
        self.destinations_excluded = destinations_excluded
        self.direction = direction
        self.disabled = disabled
        self.ip_protocol = ip_protocol
        self.is_default = is_default
        self.logged = logged
        self.notes = notes
        self.priority = priority
        self.rule_tag = rule_tag
        self.sources = sources
        self.sources_excluded = sources_excluded
        self.context_profiles = context_profiles
        self.extended_sources = extended_sources
        self.section_id = section_id
        self.services = services
        VapiStruct.__init__(self)


FirewallRule._set_binding_type(type.StructType(
    'com.vmware.nsx.model.firewall_rule', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_owner': type.OptionalType(type.ReferenceType(__name__, 'OwnerResourceLink')),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'action': type.OptionalType(type.StringType()),
        'applied_tos': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceReference'))),
        'destinations': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceReference'))),
        'destinations_excluded': type.OptionalType(type.BooleanType()),
        'direction': type.OptionalType(type.StringType()),
        'disabled': type.OptionalType(type.BooleanType()),
        'ip_protocol': type.OptionalType(type.StringType()),
        'is_default': type.OptionalType(type.BooleanType()),
        'logged': type.OptionalType(type.BooleanType()),
        'notes': type.OptionalType(type.StringType()),
        'priority': type.OptionalType(type.IntegerType()),
        'rule_tag': type.OptionalType(type.StringType()),
        'sources': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceReference'))),
        'sources_excluded': type.OptionalType(type.BooleanType()),
        'context_profiles': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceReference'))),
        'extended_sources': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceReference'))),
        'section_id': type.OptionalType(type.StringType()),
        'services': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'FirewallService'))),
    },
    FirewallRule,
    False,
    None))



class FirewallRuleList(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'rules': 'rules',
                            }

    def __init__(self,
                 rules=None,
                ):
        """
        :type  rules: :class:`list` of :class:`FirewallRule` or ``None``
        :param rules: List of firewall rules in the section. Only homogenous rules are
            supported.
        """
        self.rules = rules
        VapiStruct.__init__(self)


FirewallRuleList._set_binding_type(type.StructType(
    'com.vmware.nsx.model.firewall_rule_list', {
        'rules': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'FirewallRule'))),
    },
    FirewallRuleList,
    False,
    None))



class FirewallRuleListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`FirewallRule` or ``None``
        :param results: Firewall rule list result with pagination support.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


FirewallRuleListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.firewall_rule_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'FirewallRule'))),
    },
    FirewallRuleListResult,
    False,
    None))



class FirewallSection(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    SECTION_TYPE_LAYER2 = "LAYER2"
    """


    """
    SECTION_TYPE_LAYER3 = "LAYER3"
    """


    """
    SECTION_TYPE_L3REDIRECT = "L3REDIRECT"
    """


    """
    SECTION_TYPE_IDS = "IDS"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'applied_tos': 'applied_tos',
                            'is_default': 'is_default',
                            'rule_count': 'rule_count',
                            'section_type': 'section_type',
                            'stateful': 'stateful',
                            'autoplumbed': 'autoplumbed',
                            'category': 'category',
                            'comments': 'comments',
                            'enforced_on': 'enforced_on',
                            'firewall_schedule': 'firewall_schedule',
                            'lock_modified_by': 'lock_modified_by',
                            'lock_modified_time': 'lock_modified_time',
                            'locked': 'locked',
                            'priority': 'priority',
                            'tcp_strict': 'tcp_strict',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 applied_tos=None,
                 is_default=None,
                 rule_count=None,
                 section_type=None,
                 stateful=None,
                 autoplumbed=None,
                 category=None,
                 comments=None,
                 enforced_on=None,
                 firewall_schedule=None,
                 lock_modified_by=None,
                 lock_modified_time=None,
                 locked=None,
                 priority=None,
                 tcp_strict=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  applied_tos: :class:`list` of :class:`ResourceReference` or ``None``
        :param applied_tos: List of objects where the rules in this section will be enforced.
            This will take precedence over rule level appliedTo.
        :type  is_default: :class:`bool` or ``None``
        :param is_default: It is a boolean flag which reflects whether a distributed service
            section is default section or not. Each Layer 3 and Layer 2 section
            will have at least and at most one default section.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  rule_count: :class:`long` or ``None``
        :param rule_count: Number of rules in this section. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  section_type: :class:`str` or ``None``
        :param section_type: Possible values are: 
            
            * :attr:`FirewallSection.SECTION_TYPE_LAYER2`
            * :attr:`FirewallSection.SECTION_TYPE_LAYER3`
            * :attr:`FirewallSection.SECTION_TYPE_L3REDIRECT`
            * :attr:`FirewallSection.SECTION_TYPE_IDS`
            
            Type of the rules which a section can contain. Only homogeneous
            sections are supported.
        :type  stateful: :class:`bool` or ``None``
        :param stateful: Stateful or Stateless nature of distributed service section is
            enforced on all rules inside the section. Layer3 sections can be
            stateful or stateless. Layer2 sections can only be stateless.
        :type  autoplumbed: :class:`bool` or ``None``
        :param autoplumbed: This flag indicates whether it is an auto-plumbed section that is
            associated to a LogicalRouter. Auto-plumbed sections are system
            owned and cannot be updated via the API.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  category: :class:`str` or ``None``
        :param category: Category from policy framework.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  comments: :class:`str` or ``None``
        :param comments: Comments for section lock/unlock.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  enforced_on: :class:`str` or ``None``
        :param enforced_on: This attribute represents enforcement point of firewall section.
            For example, firewall section enforced on logical port with
            attachment type bridge endpoint will have 'BRIDGEENDPOINT' value,
            firewall section enforced on logical router will have
            'LOGICALROUTER' value and rest have 'VIF' value.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  firewall_schedule: :class:`ResourceReference` or ``None``
        :param firewall_schedule: Reference of the firewall schedule during which this section will
            be valid.
        :type  lock_modified_by: :class:`str` or ``None``
        :param lock_modified_by: ID of the user who last modified the lock for the section.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  lock_modified_time: :class:`long` or ``None``
        :param lock_modified_time: Section locked/unlocked time in epoch milliseconds. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  locked: :class:`bool` or ``None``
        :param locked: Section is locked/unlocked.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  priority: :class:`long` or ``None``
        :param priority: Priority of current section with respect to other sections. In case
            the field is empty, the list section api should be used to get
            section priority. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  tcp_strict: :class:`bool` or ``None``
        :param tcp_strict: If TCP strict is enabled on a section and a packet matches rule in
            it, the following check will be performed. If the packet does not
            belong to an existing session, the kernel will check to see if the
            SYN flag of the packet is set. If it is not, then it will drop the
            packet.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.applied_tos = applied_tos
        self.is_default = is_default
        self.rule_count = rule_count
        self.section_type = section_type
        self.stateful = stateful
        self.autoplumbed = autoplumbed
        self.category = category
        self.comments = comments
        self.enforced_on = enforced_on
        self.firewall_schedule = firewall_schedule
        self.lock_modified_by = lock_modified_by
        self.lock_modified_time = lock_modified_time
        self.locked = locked
        self.priority = priority
        self.tcp_strict = tcp_strict
        VapiStruct.__init__(self)


FirewallSection._set_binding_type(type.StructType(
    'com.vmware.nsx.model.firewall_section', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'applied_tos': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceReference'))),
        'is_default': type.OptionalType(type.BooleanType()),
        'rule_count': type.OptionalType(type.IntegerType()),
        'section_type': type.OptionalType(type.StringType()),
        'stateful': type.OptionalType(type.BooleanType()),
        'autoplumbed': type.OptionalType(type.BooleanType()),
        'category': type.OptionalType(type.StringType()),
        'comments': type.OptionalType(type.StringType()),
        'enforced_on': type.OptionalType(type.StringType()),
        'firewall_schedule': type.OptionalType(type.ReferenceType(__name__, 'ResourceReference')),
        'lock_modified_by': type.OptionalType(type.StringType()),
        'lock_modified_time': type.OptionalType(type.IntegerType()),
        'locked': type.OptionalType(type.BooleanType()),
        'priority': type.OptionalType(type.IntegerType()),
        'tcp_strict': type.OptionalType(type.BooleanType()),
    },
    FirewallSection,
    False,
    None))



class FirewallSectionListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`FirewallSection` or ``None``
        :param results: List of the firewall sections. The list has to be homogenous.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


FirewallSectionListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.firewall_section_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'FirewallSection'))),
    },
    FirewallSectionListResult,
    False,
    None))



class FirewallSectionLock(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'comments': 'comments',
                            'section_revision': 'section_revision',
                            }

    def __init__(self,
                 comments=None,
                 section_revision=None,
                ):
        """
        :type  comments: :class:`str` or ``None``
        :param comments: Comments for section lock/unlock.
        :type  section_revision: :class:`long` or ``None``
        :param section_revision: Revision of the section. format: int64
        """
        self.comments = comments
        self.section_revision = section_revision
        VapiStruct.__init__(self)


FirewallSectionLock._set_binding_type(type.StructType(
    'com.vmware.nsx.model.firewall_section_lock', {
        'comments': type.OptionalType(type.StringType()),
        'section_revision': type.OptionalType(type.IntegerType()),
    },
    FirewallSectionLock,
    False,
    None))



class FirewallSectionRuleList(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    SECTION_TYPE_LAYER2 = "LAYER2"
    """


    """
    SECTION_TYPE_LAYER3 = "LAYER3"
    """


    """
    SECTION_TYPE_L3REDIRECT = "L3REDIRECT"
    """


    """
    SECTION_TYPE_IDS = "IDS"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'applied_tos': 'applied_tos',
                            'is_default': 'is_default',
                            'rule_count': 'rule_count',
                            'section_type': 'section_type',
                            'stateful': 'stateful',
                            'autoplumbed': 'autoplumbed',
                            'category': 'category',
                            'comments': 'comments',
                            'enforced_on': 'enforced_on',
                            'firewall_schedule': 'firewall_schedule',
                            'lock_modified_by': 'lock_modified_by',
                            'lock_modified_time': 'lock_modified_time',
                            'locked': 'locked',
                            'priority': 'priority',
                            'tcp_strict': 'tcp_strict',
                            'rules': 'rules',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 applied_tos=None,
                 is_default=None,
                 rule_count=None,
                 section_type=None,
                 stateful=None,
                 autoplumbed=None,
                 category=None,
                 comments=None,
                 enforced_on=None,
                 firewall_schedule=None,
                 lock_modified_by=None,
                 lock_modified_time=None,
                 locked=None,
                 priority=None,
                 tcp_strict=None,
                 rules=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  applied_tos: :class:`list` of :class:`ResourceReference` or ``None``
        :param applied_tos: List of objects where the rules in this section will be enforced.
            This will take precedence over rule level appliedTo.
        :type  is_default: :class:`bool` or ``None``
        :param is_default: It is a boolean flag which reflects whether a distributed service
            section is default section or not. Each Layer 3 and Layer 2 section
            will have at least and at most one default section.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  rule_count: :class:`long` or ``None``
        :param rule_count: Number of rules in this section. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  section_type: :class:`str` or ``None``
        :param section_type: Possible values are: 
            
            * :attr:`FirewallSectionRuleList.SECTION_TYPE_LAYER2`
            * :attr:`FirewallSectionRuleList.SECTION_TYPE_LAYER3`
            * :attr:`FirewallSectionRuleList.SECTION_TYPE_L3REDIRECT`
            * :attr:`FirewallSectionRuleList.SECTION_TYPE_IDS`
            
            Type of the rules which a section can contain. Only homogeneous
            sections are supported.
        :type  stateful: :class:`bool` or ``None``
        :param stateful: Stateful or Stateless nature of distributed service section is
            enforced on all rules inside the section. Layer3 sections can be
            stateful or stateless. Layer2 sections can only be stateless.
        :type  autoplumbed: :class:`bool` or ``None``
        :param autoplumbed: This flag indicates whether it is an auto-plumbed section that is
            associated to a LogicalRouter. Auto-plumbed sections are system
            owned and cannot be updated via the API.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  category: :class:`str` or ``None``
        :param category: Category from policy framework.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  comments: :class:`str` or ``None``
        :param comments: Comments for section lock/unlock.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  enforced_on: :class:`str` or ``None``
        :param enforced_on: This attribute represents enforcement point of firewall section.
            For example, firewall section enforced on logical port with
            attachment type bridge endpoint will have 'BRIDGEENDPOINT' value,
            firewall section enforced on logical router will have
            'LOGICALROUTER' value and rest have 'VIF' value.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  firewall_schedule: :class:`ResourceReference` or ``None``
        :param firewall_schedule: Reference of the firewall schedule during which this section will
            be valid.
        :type  lock_modified_by: :class:`str` or ``None``
        :param lock_modified_by: ID of the user who last modified the lock for the section.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  lock_modified_time: :class:`long` or ``None``
        :param lock_modified_time: Section locked/unlocked time in epoch milliseconds. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  locked: :class:`bool` or ``None``
        :param locked: Section is locked/unlocked.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  priority: :class:`long` or ``None``
        :param priority: Priority of current section with respect to other sections. In case
            the field is empty, the list section api should be used to get
            section priority. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  tcp_strict: :class:`bool` or ``None``
        :param tcp_strict: If TCP strict is enabled on a section and a packet matches rule in
            it, the following check will be performed. If the packet does not
            belong to an existing session, the kernel will check to see if the
            SYN flag of the packet is set. If it is not, then it will drop the
            packet.
        :type  rules: :class:`list` of :class:`FirewallRule` or ``None``
        :param rules: List of firewall rules in the section. Only homogenous rules are
            supported.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.applied_tos = applied_tos
        self.is_default = is_default
        self.rule_count = rule_count
        self.section_type = section_type
        self.stateful = stateful
        self.autoplumbed = autoplumbed
        self.category = category
        self.comments = comments
        self.enforced_on = enforced_on
        self.firewall_schedule = firewall_schedule
        self.lock_modified_by = lock_modified_by
        self.lock_modified_time = lock_modified_time
        self.locked = locked
        self.priority = priority
        self.tcp_strict = tcp_strict
        self.rules = rules
        VapiStruct.__init__(self)


FirewallSectionRuleList._set_binding_type(type.StructType(
    'com.vmware.nsx.model.firewall_section_rule_list', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'applied_tos': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceReference'))),
        'is_default': type.OptionalType(type.BooleanType()),
        'rule_count': type.OptionalType(type.IntegerType()),
        'section_type': type.OptionalType(type.StringType()),
        'stateful': type.OptionalType(type.BooleanType()),
        'autoplumbed': type.OptionalType(type.BooleanType()),
        'category': type.OptionalType(type.StringType()),
        'comments': type.OptionalType(type.StringType()),
        'enforced_on': type.OptionalType(type.StringType()),
        'firewall_schedule': type.OptionalType(type.ReferenceType(__name__, 'ResourceReference')),
        'lock_modified_by': type.OptionalType(type.StringType()),
        'lock_modified_time': type.OptionalType(type.IntegerType()),
        'locked': type.OptionalType(type.BooleanType()),
        'priority': type.OptionalType(type.IntegerType()),
        'tcp_strict': type.OptionalType(type.BooleanType()),
        'rules': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'FirewallRule'))),
    },
    FirewallSectionRuleList,
    False,
    None))



class FirewallSectionState(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATE_PENDING = "pending"
    """


    """
    STATE_IN_PROGRESS = "in_progress"
    """


    """
    STATE_SUCCESS = "success"
    """


    """
    STATE_FAILED = "failed"
    """


    """
    STATE_PARTIAL_SUCCESS = "partial_success"
    """


    """
    STATE_ORPHANED = "orphaned"
    """


    """
    STATE_UNKNOWN = "unknown"
    """


    """
    STATE_ERROR = "error"
    """


    """
    STATE_IN_SYNC = "in_sync"
    """


    """
    STATE_NOT_AVAILABLE = "NOT_AVAILABLE"
    """


    """
    STATE_VM_DEPLOYMENT_QUEUED = "VM_DEPLOYMENT_QUEUED"
    """


    """
    STATE_VM_DEPLOYMENT_IN_PROGRESS = "VM_DEPLOYMENT_IN_PROGRESS"
    """


    """
    STATE_VM_DEPLOYMENT_FAILED = "VM_DEPLOYMENT_FAILED"
    """


    """
    STATE_VM_POWER_ON_IN_PROGRESS = "VM_POWER_ON_IN_PROGRESS"
    """


    """
    STATE_VM_POWER_ON_FAILED = "VM_POWER_ON_FAILED"
    """


    """
    STATE_REGISTRATION_PENDING = "REGISTRATION_PENDING"
    """


    """
    STATE_NODE_NOT_READY = "NODE_NOT_READY"
    """


    """
    STATE_NODE_READY = "NODE_READY"
    """


    """
    STATE_VM_POWER_OFF_IN_PROGRESS = "VM_POWER_OFF_IN_PROGRESS"
    """


    """
    STATE_VM_POWER_OFF_FAILED = "VM_POWER_OFF_FAILED"
    """


    """
    STATE_VM_UNDEPLOY_IN_PROGRESS = "VM_UNDEPLOY_IN_PROGRESS"
    """


    """
    STATE_VM_UNDEPLOY_FAILED = "VM_UNDEPLOY_FAILED"
    """


    """
    STATE_VM_UNDEPLOY_SUCCESSFUL = "VM_UNDEPLOY_SUCCESSFUL"
    """


    """
    STATE_EDGE_CONFIG_ERROR = "EDGE_CONFIG_ERROR"
    """


    """
    STATE_VM_DEPLOYMENT_RESTARTED = "VM_DEPLOYMENT_RESTARTED"
    """


    """
    STATE_REGISTRATION_FAILED = "REGISTRATION_FAILED"
    """


    """
    STATE_TRANSPORT_NODE_SYNC_PENDING = "TRANSPORT_NODE_SYNC_PENDING"
    """


    """
    STATE_TRANSPORT_NODE_CONFIGURATION_MISSING = "TRANSPORT_NODE_CONFIGURATION_MISSING"
    """


    """
    STATE_EDGE_HARDWARE_NOT_SUPPORTED = "EDGE_HARDWARE_NOT_SUPPORTED"
    """


    """
    STATE_MULTIPLE_OVERLAY_TZS_NOT_SUPPORTED = "MULTIPLE_OVERLAY_TZS_NOT_SUPPORTED"
    """


    """
    STATE_TN_OVERLAY_TZ_IN_USE_BY_EDGE_CLUSTER = "TN_OVERLAY_TZ_IN_USE_BY_EDGE_CLUSTER"
    """


    """
    STATE_TZ_ENDPOINTS_NOT_SPECIFIED = "TZ_ENDPOINTS_NOT_SPECIFIED"
    """


    """
    STATE_NO_PNIC_PREPARED_IN_EDGE = "NO_PNIC_PREPARED_IN_EDGE"
    """


    """
    STATE_APPLIANCE_INTERNAL_ERROR = "APPLIANCE_INTERNAL_ERROR"
    """


    """
    STATE_VTEP_DHCP_NOT_SUPPORTED = "VTEP_DHCP_NOT_SUPPORTED"
    """


    """
    STATE_UNSUPPORTED_HOST_SWITCH_PROFILE = "UNSUPPORTED_HOST_SWITCH_PROFILE"
    """


    """
    STATE_UPLINK_HOST_SWITCH_PROFILE_NOT_SPECIFIED = "UPLINK_HOST_SWITCH_PROFILE_NOT_SPECIFIED"
    """


    """
    STATE_HOSTSWITCH_PROFILE_NOT_FOUND = "HOSTSWITCH_PROFILE_NOT_FOUND"
    """


    """
    STATE_LLDP_SEND_ENABLED_NOT_SUPPORTED = "LLDP_SEND_ENABLED_NOT_SUPPORTED"
    """


    """
    STATE_UNSUPPORTED_NAMED_TEAMING_POLICY = "UNSUPPORTED_NAMED_TEAMING_POLICY"
    """


    """
    STATE_LBSRCID_NOT_SUPPORTED_FOR_EDGE_VM = "LBSRCID_NOT_SUPPORTED_FOR_EDGE_VM"
    """


    """
    STATE_LACP_NOT_SUPPORTED_FOR_EDGE_VM = "LACP_NOT_SUPPORTED_FOR_EDGE_VM"
    """


    """
    STATE_STANDBY_UPLINKS_NOT_SUPPORTED_FOR_EDGE_VM = "STANDBY_UPLINKS_NOT_SUPPORTED_FOR_EDGE_VM"
    """


    """
    STATE_MULTIPLE_ACTIVE_UPLINKS_NOT_SUPPORTED_FOR_EDGE = "MULTIPLE_ACTIVE_UPLINKS_NOT_SUPPORTED_FOR_EDGE"
    """


    """
    STATE_UNSUPPORTED_LACP_LB_ALGO_FOR_NODE = "UNSUPPORTED_LACP_LB_ALGO_FOR_NODE"
    """


    """
    STATE_EDGE_NODE_VERSION_NOT_SUPPORTED = "EDGE_NODE_VERSION_NOT_SUPPORTED"
    """


    """
    STATE_NO_PNIC_SPECIFIED_IN_TN = "NO_PNIC_SPECIFIED_IN_TN"
    """


    """
    STATE_INVALID_PNIC_DEVICE_NAME = "INVALID_PNIC_DEVICE_NAME"
    """


    """
    STATE_TRANSPORT_NODE_READY = "TRANSPORT_NODE_READY"
    """


    """
    STATE_VM_NETWORK_EDIT_PENDING = "VM_NETWORK_EDIT_PENDING"
    """


    """
    STATE_UNSUPPORTED_DEFAULT_TEAMING_POLICY = "UNSUPPORTED_DEFAULT_TEAMING_POLICY"
    """


    """
    STATE_MPA_DISCONNECTED = "MPA_DISCONNECTED"
    """


    """
    STATE_VM_RENAME_PENDING = "VM_RENAME_PENDING"
    """


    """
    STATE_VM_CONFIG_EDIT_PENDING = "VM_CONFIG_EDIT_PENDING"
    """


    """
    STATE_VM_NETWORK_EDIT_FAILED = "VM_NETWORK_EDIT_FAILED"
    """


    """
    STATE_VM_RENAME_FAILED = "VM_RENAME_FAILED"
    """


    """
    STATE_VM_CONFIG_EDIT_FAILED = "VM_CONFIG_EDIT_FAILED"
    """


    """
    STATE_VM_CONFIG_DISCREPANCY = "VM_CONFIG_DISCREPANCY"
    """


    """
    STATE_VM_NODE_REFRESH_FAILED = "VM_NODE_REFRESH_FAILED"
    """


    """
    STATE_VM_PLACEMENT_REFRESH_FAILED = "VM_PLACEMENT_REFRESH_FAILED"
    """


    """
    STATE_REGISTRATION_TIMEDOUT = "REGISTRATION_TIMEDOUT"
    """


    """



    _canonical_to_pep_names = {
                            'details': 'details',
                            'failure_code': 'failure_code',
                            'failure_message': 'failure_message',
                            'state': 'state',
                            'revision_desired': 'revision_desired',
                            'pending_change_list': 'pending_change_list',
                            }

    def __init__(self,
                 details=None,
                 failure_code=None,
                 failure_message=None,
                 state=None,
                 revision_desired=None,
                 pending_change_list=None,
                ):
        """
        :type  details: :class:`list` of :class:`ConfigurationStateElement` or ``None``
        :param details: Array of configuration state of various sub systems
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  failure_code: :class:`long` or ``None``
        :param failure_code: Error code format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  failure_message: :class:`str` or ``None``
        :param failure_message: Error message in case of failure
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  state: :class:`str` or ``None``
        :param state: Possible values are: 
            
            * :attr:`FirewallSectionState.STATE_PENDING`
            * :attr:`FirewallSectionState.STATE_IN_PROGRESS`
            * :attr:`FirewallSectionState.STATE_SUCCESS`
            * :attr:`FirewallSectionState.STATE_FAILED`
            * :attr:`FirewallSectionState.STATE_PARTIAL_SUCCESS`
            * :attr:`FirewallSectionState.STATE_ORPHANED`
            * :attr:`FirewallSectionState.STATE_UNKNOWN`
            * :attr:`FirewallSectionState.STATE_ERROR`
            * :attr:`FirewallSectionState.STATE_IN_SYNC`
            * :attr:`FirewallSectionState.STATE_NOT_AVAILABLE`
            * :attr:`FirewallSectionState.STATE_VM_DEPLOYMENT_QUEUED`
            * :attr:`FirewallSectionState.STATE_VM_DEPLOYMENT_IN_PROGRESS`
            * :attr:`FirewallSectionState.STATE_VM_DEPLOYMENT_FAILED`
            * :attr:`FirewallSectionState.STATE_VM_POWER_ON_IN_PROGRESS`
            * :attr:`FirewallSectionState.STATE_VM_POWER_ON_FAILED`
            * :attr:`FirewallSectionState.STATE_REGISTRATION_PENDING`
            * :attr:`FirewallSectionState.STATE_NODE_NOT_READY`
            * :attr:`FirewallSectionState.STATE_NODE_READY`
            * :attr:`FirewallSectionState.STATE_VM_POWER_OFF_IN_PROGRESS`
            * :attr:`FirewallSectionState.STATE_VM_POWER_OFF_FAILED`
            * :attr:`FirewallSectionState.STATE_VM_UNDEPLOY_IN_PROGRESS`
            * :attr:`FirewallSectionState.STATE_VM_UNDEPLOY_FAILED`
            * :attr:`FirewallSectionState.STATE_VM_UNDEPLOY_SUCCESSFUL`
            * :attr:`FirewallSectionState.STATE_EDGE_CONFIG_ERROR`
            * :attr:`FirewallSectionState.STATE_VM_DEPLOYMENT_RESTARTED`
            * :attr:`FirewallSectionState.STATE_REGISTRATION_FAILED`
            * :attr:`FirewallSectionState.STATE_TRANSPORT_NODE_SYNC_PENDING`
            *
              :attr:`FirewallSectionState.STATE_TRANSPORT_NODE_CONFIGURATION_MISSING`
            * :attr:`FirewallSectionState.STATE_EDGE_HARDWARE_NOT_SUPPORTED`
            *
              :attr:`FirewallSectionState.STATE_MULTIPLE_OVERLAY_TZS_NOT_SUPPORTED`
            *
              :attr:`FirewallSectionState.STATE_TN_OVERLAY_TZ_IN_USE_BY_EDGE_CLUSTER`
            * :attr:`FirewallSectionState.STATE_TZ_ENDPOINTS_NOT_SPECIFIED`
            * :attr:`FirewallSectionState.STATE_NO_PNIC_PREPARED_IN_EDGE`
            * :attr:`FirewallSectionState.STATE_APPLIANCE_INTERNAL_ERROR`
            * :attr:`FirewallSectionState.STATE_VTEP_DHCP_NOT_SUPPORTED`
            *
              :attr:`FirewallSectionState.STATE_UNSUPPORTED_HOST_SWITCH_PROFILE`
            *
              :attr:`FirewallSectionState.STATE_UPLINK_HOST_SWITCH_PROFILE_NOT_SPECIFIED`
            * :attr:`FirewallSectionState.STATE_HOSTSWITCH_PROFILE_NOT_FOUND`
            *
              :attr:`FirewallSectionState.STATE_LLDP_SEND_ENABLED_NOT_SUPPORTED`
            *
              :attr:`FirewallSectionState.STATE_UNSUPPORTED_NAMED_TEAMING_POLICY`
            *
              :attr:`FirewallSectionState.STATE_LBSRCID_NOT_SUPPORTED_FOR_EDGE_VM`
            * :attr:`FirewallSectionState.STATE_LACP_NOT_SUPPORTED_FOR_EDGE_VM`
            *
              :attr:`FirewallSectionState.STATE_STANDBY_UPLINKS_NOT_SUPPORTED_FOR_EDGE_VM`
            *
              :attr:`FirewallSectionState.STATE_MULTIPLE_ACTIVE_UPLINKS_NOT_SUPPORTED_FOR_EDGE`
            *
              :attr:`FirewallSectionState.STATE_UNSUPPORTED_LACP_LB_ALGO_FOR_NODE`
            *
              :attr:`FirewallSectionState.STATE_EDGE_NODE_VERSION_NOT_SUPPORTED`
            * :attr:`FirewallSectionState.STATE_NO_PNIC_SPECIFIED_IN_TN`
            * :attr:`FirewallSectionState.STATE_INVALID_PNIC_DEVICE_NAME`
            * :attr:`FirewallSectionState.STATE_TRANSPORT_NODE_READY`
            * :attr:`FirewallSectionState.STATE_VM_NETWORK_EDIT_PENDING`
            *
              :attr:`FirewallSectionState.STATE_UNSUPPORTED_DEFAULT_TEAMING_POLICY`
            * :attr:`FirewallSectionState.STATE_MPA_DISCONNECTED`
            * :attr:`FirewallSectionState.STATE_VM_RENAME_PENDING`
            * :attr:`FirewallSectionState.STATE_VM_CONFIG_EDIT_PENDING`
            * :attr:`FirewallSectionState.STATE_VM_NETWORK_EDIT_FAILED`
            * :attr:`FirewallSectionState.STATE_VM_RENAME_FAILED`
            * :attr:`FirewallSectionState.STATE_VM_CONFIG_EDIT_FAILED`
            * :attr:`FirewallSectionState.STATE_VM_CONFIG_DISCREPANCY`
            * :attr:`FirewallSectionState.STATE_VM_NODE_REFRESH_FAILED`
            * :attr:`FirewallSectionState.STATE_VM_PLACEMENT_REFRESH_FAILED`
            * :attr:`FirewallSectionState.STATE_REGISTRATION_TIMEDOUT`
            
            Gives details of state of desired configuration. Additional enums
            with more details on progress/success/error states are sent for
            edge node. The success states are NODE_READY and
            TRANSPORT_NODE_READY, pending states are {VM_DEPLOYMENT_QUEUED,
            VM_DEPLOYMENT_IN_PROGRESS, REGISTRATION_PENDING} and other values
            indicate failures. \"in_sync\" state indicates that the desired
            configuration has been received by the host to which it applies,
            but is not yet in effect. When the configuration is actually in
            effect, the state will change to \"success\". Please note, failed
            state is deprecated.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  revision_desired: :class:`long` or ``None``
        :param revision_desired: This attribute represents revision number of section's desired
            state. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  pending_change_list: :class:`list` of :class:`PendingChange` or ``None``
        :param pending_change_list: Pending changes to be realized.
        """
        self.details = details
        self.failure_code = failure_code
        self.failure_message = failure_message
        self.state = state
        self.revision_desired = revision_desired
        self.pending_change_list = pending_change_list
        VapiStruct.__init__(self)


FirewallSectionState._set_binding_type(type.StructType(
    'com.vmware.nsx.model.firewall_section_state', {
        'details': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ConfigurationStateElement'))),
        'failure_code': type.OptionalType(type.IntegerType()),
        'failure_message': type.OptionalType(type.StringType()),
        'state': type.OptionalType(type.StringType()),
        'revision_desired': type.OptionalType(type.IntegerType()),
        'pending_change_list': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'PendingChange'))),
    },
    FirewallSectionState,
    False,
    None))



class FirewallSectionsSummary(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    SECTION_TYPE_L2DFW = "L2DFW"
    """


    """
    SECTION_TYPE_L3DFW = "L3DFW"
    """


    """
    SECTION_TYPE_L3BRIDGEPORTFW = "L3BRIDGEPORTFW"
    """


    """
    SECTION_TYPE_L3LOGICALROUTERFW = "L3LOGICALROUTERFW"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'rule_count': 'rule_count',
                            'section_count': 'section_count',
                            'section_type': 'section_type',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 rule_count=None,
                 section_count=None,
                 section_type=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  rule_count: :class:`long` or ``None``
        :param rule_count: Total number of rules in the section. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  section_count: :class:`long` or ``None``
        :param section_count: Total number of sections for the section type. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  section_type: :class:`str` or ``None``
        :param section_type: Possible values are: 
            
            * :attr:`FirewallSectionsSummary.SECTION_TYPE_L2DFW`
            * :attr:`FirewallSectionsSummary.SECTION_TYPE_L3DFW`
            * :attr:`FirewallSectionsSummary.SECTION_TYPE_L3BRIDGEPORTFW`
            * :attr:`FirewallSectionsSummary.SECTION_TYPE_L3LOGICALROUTERFW`
            
             Type of rules which a section can contain.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.rule_count = rule_count
        self.section_count = section_count
        self.section_type = section_type
        VapiStruct.__init__(self)


FirewallSectionsSummary._set_binding_type(type.StructType(
    'com.vmware.nsx.model.firewall_sections_summary', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'rule_count': type.OptionalType(type.IntegerType()),
        'section_count': type.OptionalType(type.IntegerType()),
        'section_type': type.OptionalType(type.StringType()),
    },
    FirewallSectionsSummary,
    False,
    None))



class FirewallSectionsSummaryList(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'last_compute_time': 'last_compute_time',
                            'sections_summary': 'sections_summary',
                            }

    def __init__(self,
                 last_compute_time=None,
                 sections_summary=None,
                ):
        """
        :type  last_compute_time: :class:`long` or ``None``
        :param last_compute_time: Timestamp of the last computation, in epoch milliseconds. format:
            int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sections_summary: :class:`list` of :class:`FirewallSectionsSummary` or ``None``
        :param sections_summary: List of firewall sections summary.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.last_compute_time = last_compute_time
        self.sections_summary = sections_summary
        VapiStruct.__init__(self)


FirewallSectionsSummaryList._set_binding_type(type.StructType(
    'com.vmware.nsx.model.firewall_sections_summary_list', {
        'last_compute_time': type.OptionalType(type.IntegerType()),
        'sections_summary': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'FirewallSectionsSummary'))),
    },
    FirewallSectionsSummaryList,
    False,
    None))



class FirewallService(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'is_valid': 'is_valid',
                            'target_display_name': 'target_display_name',
                            'target_id': 'target_id',
                            'target_type': 'target_type',
                            'service': 'service',
                            }

    def __init__(self,
                 is_valid=None,
                 target_display_name=None,
                 target_id=None,
                 target_type=None,
                 service=None,
                ):
        """
        :type  is_valid: :class:`bool` or ``None``
        :param is_valid: Will be set to false if the referenced NSX resource has been
            deleted.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  target_display_name: :class:`str` or ``None``
        :param target_display_name: Display name of the NSX resource.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  target_id: :class:`str` or ``None``
        :param target_id: Identifier of the NSX resource.
        :type  target_type: :class:`str` or ``None``
        :param target_type: Type of the NSX resource.
        :type  service: :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param service: Distributed Service API accepts raw protocol and ports as part of
            NS service element in Distributed Service Rule that describes
            traffic corresponding to an NSService.
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`NSServiceElement`. When methods return a value of this
            class as a return value, the attribute will contain all the
            attributes defined in :class:`NSServiceElement`.
        """
        self.is_valid = is_valid
        self.target_display_name = target_display_name
        self.target_id = target_id
        self.target_type = target_type
        self.service = service
        VapiStruct.__init__(self)


FirewallService._set_binding_type(type.StructType(
    'com.vmware.nsx.model.firewall_service', {
        'is_valid': type.OptionalType(type.BooleanType()),
        'target_display_name': type.OptionalType(type.StringType()),
        'target_id': type.OptionalType(type.StringType()),
        'target_type': type.OptionalType(type.StringType()),
        'service': type.OptionalType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'NSServiceElement')])),
    },
    FirewallService,
    False,
    None))



class FirewallSessionTimerProfile(VapiStruct):
    """
    A profile holding TCP, UDP and ICMP session timeout configuration.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "FirewallSessionTimerProfile"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'icmp_error_reply': 'icmp_error_reply',
                            'icmp_first_packet': 'icmp_first_packet',
                            'tcp_closed': 'tcp_closed',
                            'tcp_closing': 'tcp_closing',
                            'tcp_established': 'tcp_established',
                            'tcp_finwait': 'tcp_finwait',
                            'tcp_first_packet': 'tcp_first_packet',
                            'tcp_opening': 'tcp_opening',
                            'udp_first_packet': 'udp_first_packet',
                            'udp_multiple': 'udp_multiple',
                            'udp_single': 'udp_single',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            }

    def __init__(self,
                 icmp_error_reply=None,
                 icmp_first_packet=None,
                 tcp_closed=None,
                 tcp_closing=None,
                 tcp_established=None,
                 tcp_finwait=None,
                 tcp_first_packet=None,
                 tcp_opening=None,
                 udp_first_packet=None,
                 udp_multiple=None,
                 udp_single=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='FirewallSessionTimerProfile',
                 tags=None,
                ):
        """
        :type  icmp_error_reply: :class:`long` or ``None``
        :param icmp_error_reply: The timeout value for the connection after an ICMP error came back
            in response to an ICMP packet. The default value for Edges (i.e,
            Gateway, or Logical Router) may be different than Distributed
            Firewall hosts. format: int64
        :type  icmp_first_packet: :class:`long` or ``None``
        :param icmp_first_packet: The timeout value of connection in seconds after the first packet.
            This will be the initial timeout for the new ICMP flow. The default
            value for Edges (i.e, Gateway, or Logical Router) may be different
            than Distributed Firewall hosts. format: int64
        :type  tcp_closed: :class:`long` or ``None``
        :param tcp_closed: The timeout value of connection in seconds after one endpoint sends
            an RST. The default value for Edges (i.e, Gateway, or Logical
            Router) may be different than Distributed Firewall hosts. format:
            int64
        :type  tcp_closing: :class:`long` or ``None``
        :param tcp_closing: The timeout value of connection in seconds after the first FIN has
            been sent. The default value for Edges (i.e, Gateway, or Logical
            Router) may be different than Distributed Firewall hosts. format:
            int64
        :type  tcp_established: :class:`long` or ``None``
        :param tcp_established: The timeout value of connection in seconds once the connection has
            become fully established. The default value for Edges (i.e,
            Gateway, or Logical Router) may be different than Distributed
            Firewall hosts. format: int64
        :type  tcp_finwait: :class:`long` or ``None``
        :param tcp_finwait: The timeout value of connection in seconds after both FINs have
            been exchanged and connection is closed. The default value for
            Edges (i.e, Gateway, or Logical Router) may be different than
            Distributed Firewall hosts. format: int64
        :type  tcp_first_packet: :class:`long` or ``None``
        :param tcp_first_packet: The timeout value of connection in seconds after the first packet
            has been sent. The default value for Edges (i.e, Gateway, or
            Logical Router) may be different than Distributed Firewall hosts.
            format: int64
        :type  tcp_opening: :class:`long` or ``None``
        :param tcp_opening: The timeout value of connection in seconds after a second packet
            has been transferred. The default value for Edges (i.e, Gateway, or
            Logical Router) may be different than Distributed Firewall hosts.
            format: int64
        :type  udp_first_packet: :class:`long` or ``None``
        :param udp_first_packet: The timeout value of connection in seconds after the first packet.
            This will be the initial timeout for the new UDP flow. The default
            value for Edges (i.e, Gateway, or Logical Router) may be different
            than Distributed Firewall hosts. format: int64
        :type  udp_multiple: :class:`long` or ``None``
        :param udp_multiple: The timeout value of connection in seconds if both hosts have sent
            packets. The default value for Edges (i.e, Gateway, or Logical
            Router) may be different than Distributed Firewall hosts. format:
            int64
        :type  udp_single: :class:`long` or ``None``
        :param udp_single: The timeout value of connection in seconds if the source host sends
            more than one packet but the destination host has never sent one
            back. The default value for Edges (i.e, Gateway, or Logical Router)
            may be different than Distributed Firewall hosts. format: int64
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            *
              :attr:`BaseFirewallProfile.RESOURCE_TYPE_FIREWALLSESSIONTIMERPROFILE`
            *
              :attr:`BaseFirewallProfile.RESOURCE_TYPE_FIREWALLCPUMEMTHRESHOLDSPROFILE`
            *
              :attr:`BaseFirewallProfile.RESOURCE_TYPE_FIREWALLFLOODPROTECTIONPROFILE`
            * :attr:`BaseFirewallProfile.RESOURCE_TYPE_FIREWALLDNSPROFILE`
            
             Resource type to use as profile type
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        """
        self.icmp_error_reply = icmp_error_reply
        self.icmp_first_packet = icmp_first_packet
        self.tcp_closed = tcp_closed
        self.tcp_closing = tcp_closing
        self.tcp_established = tcp_established
        self.tcp_finwait = tcp_finwait
        self.tcp_first_packet = tcp_first_packet
        self.tcp_opening = tcp_opening
        self.udp_first_packet = udp_first_packet
        self.udp_multiple = udp_multiple
        self.udp_single = udp_single
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

FirewallSessionTimerProfile._set_binding_type(type.StructType(
    'com.vmware.nsx.model.firewall_session_timer_profile', {
        'icmp_error_reply': type.OptionalType(type.IntegerType()),
        'icmp_first_packet': type.OptionalType(type.IntegerType()),
        'tcp_closed': type.OptionalType(type.IntegerType()),
        'tcp_closing': type.OptionalType(type.IntegerType()),
        'tcp_established': type.OptionalType(type.IntegerType()),
        'tcp_finwait': type.OptionalType(type.IntegerType()),
        'tcp_first_packet': type.OptionalType(type.IntegerType()),
        'tcp_opening': type.OptionalType(type.IntegerType()),
        'udp_first_packet': type.OptionalType(type.IntegerType()),
        'udp_multiple': type.OptionalType(type.IntegerType()),
        'udp_single': type.OptionalType(type.IntegerType()),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
    },
    FirewallSessionTimerProfile,
    False,
    None))



class FirewallStats(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'byte_count': 'byte_count',
                            'hit_count': 'hit_count',
                            'max_popularity_index': 'max_popularity_index',
                            'max_session_count': 'max_session_count',
                            'packet_count': 'packet_count',
                            'popularity_index': 'popularity_index',
                            'rule_id': 'rule_id',
                            'session_count': 'session_count',
                            'total_session_count': 'total_session_count',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 byte_count=None,
                 hit_count=None,
                 max_popularity_index=None,
                 max_session_count=None,
                 packet_count=None,
                 popularity_index=None,
                 rule_id=None,
                 session_count=None,
                 total_session_count=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  byte_count: :class:`long` or ``None``
        :param byte_count: Aggregated number of bytes processed by the rule. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  hit_count: :class:`long` or ``None``
        :param hit_count: Aggregated number of hits received by the rule. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  max_popularity_index: :class:`long` or ``None``
        :param max_popularity_index: Maximum value of popularity index of all firewall rules of the
            type. This is aggregated statistic which are computed with lower
            frequency compared to individual generic rule statistics. It may
            have a computation delay up to 15 minutes in response to this API.
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  max_session_count: :class:`long` or ``None``
        :param max_session_count: Maximum value of sessions count of all firewall rules of the type.
            This is aggregated statistic which are computed with lower
            frequency compared to generic rule statistics. It may have a
            computation delay up to 15 minutes in response to this API. format:
            int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  packet_count: :class:`long` or ``None``
        :param packet_count: Aggregated number of packets processed by the rule. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  popularity_index: :class:`long` or ``None``
        :param popularity_index: This is calculated by sessions count divided by age of the rule.
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  rule_id: :class:`str` or ``None``
        :param rule_id: Rule Identifier of the Firewall rule. This is a globally unique
            number.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  session_count: :class:`long` or ``None``
        :param session_count: Aggregated number of sessions processed by the rule. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  total_session_count: :class:`long` or ``None``
        :param total_session_count: Aggregated number of sessions processed by the all firewall rules.
            This is aggregated statistic which are computed with lower
            frequency compared to individual generic rule statistics. It may
            have a computation delay up to 15 minutes in response to this API.
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.byte_count = byte_count
        self.hit_count = hit_count
        self.max_popularity_index = max_popularity_index
        self.max_session_count = max_session_count
        self.packet_count = packet_count
        self.popularity_index = popularity_index
        self.rule_id = rule_id
        self.session_count = session_count
        self.total_session_count = total_session_count
        VapiStruct.__init__(self)


FirewallStats._set_binding_type(type.StructType(
    'com.vmware.nsx.model.firewall_stats', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'byte_count': type.OptionalType(type.IntegerType()),
        'hit_count': type.OptionalType(type.IntegerType()),
        'max_popularity_index': type.OptionalType(type.IntegerType()),
        'max_session_count': type.OptionalType(type.IntegerType()),
        'packet_count': type.OptionalType(type.IntegerType()),
        'popularity_index': type.OptionalType(type.IntegerType()),
        'rule_id': type.OptionalType(type.StringType()),
        'session_count': type.OptionalType(type.IntegerType()),
        'total_session_count': type.OptionalType(type.IntegerType()),
    },
    FirewallStats,
    False,
    None))



class FirewallStatsList(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'result_count': 'result_count',
                            'results': 'results',
                            'section_id': 'section_id',
                            }

    def __init__(self,
                 result_count=None,
                 results=None,
                 section_id=None,
                ):
        """
        :type  result_count: :class:`long` or ``None``
        :param result_count: Total count for firewall rule statistics in results set format:
            int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`FirewallStats` or ``None``
        :param results: List of rule statistics
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  section_id: :class:`str` or ``None``
        :param section_id: Corresponding firewall section identifier for list of rule
            statistics
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.result_count = result_count
        self.results = results
        self.section_id = section_id
        VapiStruct.__init__(self)


FirewallStatsList._set_binding_type(type.StructType(
    'com.vmware.nsx.model.firewall_stats_list', {
        'result_count': type.OptionalType(type.IntegerType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'FirewallStats'))),
        'section_id': type.OptionalType(type.StringType()),
    },
    FirewallStatsList,
    False,
    None))



class FirewallStatus(VapiStruct):
    """
    Firewall Status Response

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    CONTEXT_TRANSPORT_NODES = "transport_nodes"
    """


    """
    CONTEXT_LOGICAL_ROUTERS = "logical_routers"
    """


    """
    CONTEXT_BRIDGE_PORTS = "bridge_ports"
    """


    """
    GLOBAL_STATUS_DISABLED = "DISABLED"
    """


    """
    GLOBAL_STATUS_ENABLED = "ENABLED"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'context': 'context',
                            'global_status': 'global_status',
                            'target_statuses': 'target_statuses',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 context=None,
                 global_status=None,
                 target_statuses=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  context: :class:`str` or ``None``
        :param context: Possible values are: 
            
            * :attr:`FirewallStatus.CONTEXT_TRANSPORT_NODES`
            * :attr:`FirewallStatus.CONTEXT_LOGICAL_ROUTERS`
            * :attr:`FirewallStatus.CONTEXT_BRIDGE_PORTS`
            
             Types of firewall contexts.
        :type  global_status: :class:`str` or ``None``
        :param global_status: Possible values are: 
            
            * :attr:`FirewallStatus.GLOBAL_STATUS_DISABLED`
            * :attr:`FirewallStatus.GLOBAL_STATUS_ENABLED`
            
            Firewall status for a fabric entity or in global context where
            firewall is supported.
        :type  target_statuses: :class:`list` of :class:`TargetResourceStatus` or ``None``
        :param target_statuses: List of firewall status on various target logical resources. This
            will override the global status of corresponding firewall context
            (e.g it will override the gloabal status of logical_routers).
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.context = context
        self.global_status = global_status
        self.target_statuses = target_statuses
        VapiStruct.__init__(self)


FirewallStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.firewall_status', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'context': type.OptionalType(type.StringType()),
        'global_status': type.OptionalType(type.StringType()),
        'target_statuses': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'TargetResourceStatus'))),
    },
    FirewallStatus,
    False,
    None))



class FirewallStatusListResult(VapiStruct):
    """
    List of firewall statuses for a context or all context

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`FirewallStatus` or ``None``
        :param results: 
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


FirewallStatusListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.firewall_status_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'FirewallStatus'))),
    },
    FirewallStatusListResult,
    False,
    None))



class Footer(VapiStruct):
    """
    Footer of a widget that provides additional information or allows an action
    such as clickable url for navigation. An example usage of footer is
    provided under 'example_request' section of 'CreateWidgetConfiguration'
    API.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'actions': 'actions',
                            'condition': 'condition',
                            }

    def __init__(self,
                 actions=None,
                 condition=None,
                ):
        """
        :type  actions: :class:`list` of :class:`FooterAction` or ``None``
        :param actions: Action to be performed at the footer of a widget. An action at the
            footer can be simple text description or a hyperlink to a UI page.
            Action allows a clickable url for navigation. An example usage of
            footer action is provided under 'example_request' section of
            'CreateWidgetConfiguration' API.
        :type  condition: :class:`str` or ``None``
        :param condition: If the condition is met then the footer will be applied. Examples
            of expression syntax are provided under 'example_request' section
            of 'CreateWidgetConfiguration' API.
        """
        self.actions = actions
        self.condition = condition
        VapiStruct.__init__(self)


Footer._set_binding_type(type.StructType(
    'com.vmware.nsx.model.footer', {
        'actions': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'FooterAction'))),
        'condition': type.OptionalType(type.StringType()),
    },
    Footer,
    False,
    None))



class FooterAction(VapiStruct):
    """
    Action specified at the footer of a widget to provide additional
    information or to provide a clickable url for navigation. An example usage
    of footer action is provided under the 'example_request' section of
    'CreateWidgetConfiguration' API.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'dock_to_container_footer': 'dock_to_container_footer',
                            'label': 'label',
                            'url': 'url',
                            }

    def __init__(self,
                 dock_to_container_footer=None,
                 label=None,
                 url=None,
                ):
        """
        :type  dock_to_container_footer: :class:`bool` or ``None``
        :param dock_to_container_footer: If true, the footer will appear in the underlying container that
            holds the widget.
        :type  label: :class:`Label` or ``None``
        :param label: Label to be displayed against the footer action.
        :type  url: :class:`str` or ``None``
        :param url: Hyperlink to the UI page that provides details of action.
        """
        self.dock_to_container_footer = dock_to_container_footer
        self.label = label
        self.url = url
        VapiStruct.__init__(self)


FooterAction._set_binding_type(type.StructType(
    'com.vmware.nsx.model.footer_action', {
        'dock_to_container_footer': type.OptionalType(type.BooleanType()),
        'label': type.OptionalType(type.ReferenceType(__name__, 'Label')),
        'url': type.OptionalType(type.StringType()),
    },
    FooterAction,
    False,
    None))



class ForwarderZone(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'source_ip': 'source_ip',
                            'upstream_servers': 'upstream_servers',
                            }

    def __init__(self,
                 source_ip=None,
                 upstream_servers=None,
                ):
        """
        :type  source_ip: :class:`str` or ``None``
        :param source_ip: The source ip used by the fowarder of the zone. If no source ip
            specified, the ip address of listener of the DNS forwarder will be
            used. format: ipv4
        :type  upstream_servers: :class:`list` of :class:`str` or ``None``
        :param upstream_servers: Ip address of the upstream DNS servers the DNS forwarder accesses.
            format: ipv4
        """
        self.source_ip = source_ip
        self.upstream_servers = upstream_servers
        VapiStruct.__init__(self)


ForwarderZone._set_binding_type(type.StructType(
    'com.vmware.nsx.model.forwarder_zone', {
        'source_ip': type.OptionalType(type.StringType()),
        'upstream_servers': type.OptionalType(type.ListType(type.StringType())),
    },
    ForwarderZone,
    False,
    None))



class GenericDhcpOption(VapiStruct):
    """
    Define DHCP options other than option 121.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'code': 'code',
                            'values': 'values',
                            }

    def __init__(self,
                 code=None,
                 values=None,
                ):
        """
        :type  code: :class:`long` or ``None``
        :param code: Code of the dhcp option. format: int64
        :type  values: :class:`list` of :class:`str` or ``None``
        :param values: Value of the option.
        """
        self.code = code
        self.values = values
        VapiStruct.__init__(self)


GenericDhcpOption._set_binding_type(type.StructType(
    'com.vmware.nsx.model.generic_dhcp_option', {
        'code': type.OptionalType(type.IntegerType()),
        'values': type.OptionalType(type.ListType(type.StringType())),
    },
    GenericDhcpOption,
    False,
    None))



class GiServiceProfile(VapiStruct):
    """
    GI Specific service profile

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "GiServiceProfile"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'service_id': 'service_id',
                            'vendor_template_id': 'vendor_template_id',
                            'vendor_template_key': 'vendor_template_key',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            }

    def __init__(self,
                 service_id=None,
                 vendor_template_id=None,
                 vendor_template_key=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='GiServiceProfile',
                 tags=None,
                ):
        """
        :type  service_id: :class:`str` or ``None``
        :param service_id: The service to which the service profile belongs.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  vendor_template_id: :class:`str` or ``None``
        :param vendor_template_id: ID of the vendor template, created by partner while registering the
            service.
        :type  vendor_template_key: :class:`str` or ``None``
        :param vendor_template_key: Different VMs in data center can have Different protection levels
            as specified by administrator in the policy. The identifier for the
            policy with which the partner appliance identifies this policy.
            This identifier will be passed to the partner appliance at runtime
            to specify which protection level is applicable for the VM being
            protected.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Service Profile type, for example 'GiServiceProfile',
            'ServiceInsertionServiceProfile'
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        """
        self.service_id = service_id
        self.vendor_template_id = vendor_template_id
        self.vendor_template_key = vendor_template_key
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

GiServiceProfile._set_binding_type(type.StructType(
    'com.vmware.nsx.model.gi_service_profile', {
        'service_id': type.OptionalType(type.StringType()),
        'vendor_template_id': type.OptionalType(type.StringType()),
        'vendor_template_key': type.OptionalType(type.StringType()),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
    },
    GiServiceProfile,
    False,
    None))



class GlobalCollectionConfiguration(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'aggregated_data_collection_frequency': 'aggregated_data_collection_frequency',
                            'is_data_collection_enabled': 'is_data_collection_enabled',
                            'modified_feature_stack_collection_configurations': 'modified_feature_stack_collection_configurations',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 aggregated_data_collection_frequency=None,
                 is_data_collection_enabled=None,
                 modified_feature_stack_collection_configurations=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  aggregated_data_collection_frequency: :class:`long` or ``None``
        :param aggregated_data_collection_frequency: The frequency in seconds at which data, which is subject to the
            aggregation function, is collected. format: int64
        :type  is_data_collection_enabled: :class:`bool` or ``None``
        :param is_data_collection_enabled: Indicates whether data collection required by the aggregation
            service is enabled. If false, no aggregation service data will be
            collected. Changing this property will not affect the existing data
            collection frequency settings.
        :type  modified_feature_stack_collection_configurations: :class:`FeatureStackCollectionConfigurationList` or ``None``
        :param modified_feature_stack_collection_configurations: The list of the locally modified feature stack data collection
            frequency settings. If all feature stack data collection
            configurations are set to their default values, this list will be
            empty.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.aggregated_data_collection_frequency = aggregated_data_collection_frequency
        self.is_data_collection_enabled = is_data_collection_enabled
        self.modified_feature_stack_collection_configurations = modified_feature_stack_collection_configurations
        VapiStruct.__init__(self)


GlobalCollectionConfiguration._set_binding_type(type.StructType(
    'com.vmware.nsx.model.global_collection_configuration', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'aggregated_data_collection_frequency': type.OptionalType(type.IntegerType()),
        'is_data_collection_enabled': type.OptionalType(type.BooleanType()),
        'modified_feature_stack_collection_configurations': type.OptionalType(type.ReferenceType(__name__, 'FeatureStackCollectionConfigurationList')),
    },
    GlobalCollectionConfiguration,
    False,
    None))



class GlobalConfigs(VapiStruct):
    """
    The GlobalConfigs is the base class for global configurations for different
    types in a NSX domain.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "GlobalConfigs"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    RESOURCE_TYPE_SWITCHINGGLOBALCONFIG = "SwitchingGlobalConfig"
    """


    """
    RESOURCE_TYPE_ROUTINGGLOBALCONFIG = "RoutingGlobalConfig"
    """


    """
    RESOURCE_TYPE_OPERATIONCOLLECTORGLOBALCONFIG = "OperationCollectorGlobalConfig"
    """


    """
    RESOURCE_TYPE_FIREWALLGLOBALCONFIG = "FirewallGlobalConfig"
    """


    """
    RESOURCE_TYPE_ESXGLOBALOPAQUECONFIG = "EsxGlobalOpaqueConfig"
    """


    """
    RESOURCE_TYPE_SECURITYGLOBALCONFIG = "SecurityGlobalConfig"
    """


    """
    RESOURCE_TYPE_FIPSGLOBALCONFIG = "FipsGlobalConfig"
    """


    """
    RESOURCE_TYPE_FEDERATIONGLOBALCONFIG = "FederationGlobalConfig"
    """


    """
    RESOURCE_TYPE_IDSGLOBALCONFIG = "IdsGlobalConfig"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='GlobalConfigs',
                 tags=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`GlobalConfigs.RESOURCE_TYPE_SWITCHINGGLOBALCONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_ROUTINGGLOBALCONFIG`
            *
              :attr:`GlobalConfigs.RESOURCE_TYPE_OPERATIONCOLLECTORGLOBALCONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_FIREWALLGLOBALCONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_ESXGLOBALOPAQUECONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_SECURITYGLOBALCONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_FIPSGLOBALCONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_FEDERATIONGLOBALCONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_IDSGLOBALCONFIG`
            
             Valid Global configuration types
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

GlobalConfigs._set_binding_type(type.StructType(
    'com.vmware.nsx.model.global_configs', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
    },
    GlobalConfigs,
    False,
    None))



class GlobalConfigsListResult(VapiStruct):
    """
    A list of global configurations grouped by their types

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param results: Domain specific global configuration.
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`GlobalConfigs`. When methods return a value of this class
            as a return value, the attribute will contain all the attributes
            defined in :class:`GlobalConfigs`.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


GlobalConfigsListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.global_configs_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'GlobalConfigs')]))),
    },
    GlobalConfigsListResult,
    False,
    None))



class GlobalRestoreStatus(VapiStruct):
    """
    Overall restore process status

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    VALUE_INITIAL = "INITIAL"
    """


    """
    VALUE_SUCCESS = "SUCCESS"
    """


    """
    VALUE_FAILED = "FAILED"
    """


    """
    VALUE_RUNNING = "RUNNING"
    """


    """
    VALUE_SUSPENDED_BY_USER = "SUSPENDED_BY_USER"
    """


    """
    VALUE_SUSPENDED_FOR_USER_ACTION = "SUSPENDED_FOR_USER_ACTION"
    """


    """
    VALUE_SUSPENDED = "SUSPENDED"
    """


    """
    VALUE_ABORTED = "ABORTED"
    """


    """



    _canonical_to_pep_names = {
                            'description': 'description',
                            'value': 'value',
                            }

    def __init__(self,
                 description=None,
                 value=None,
                ):
        """
        :type  description: :class:`str` or ``None``
        :param description: A description of the restore status
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  value: :class:`str` or ``None``
        :param value: Possible values are: 
            
            * :attr:`GlobalRestoreStatus.VALUE_INITIAL`
            * :attr:`GlobalRestoreStatus.VALUE_SUCCESS`
            * :attr:`GlobalRestoreStatus.VALUE_FAILED`
            * :attr:`GlobalRestoreStatus.VALUE_RUNNING`
            * :attr:`GlobalRestoreStatus.VALUE_SUSPENDED_BY_USER`
            * :attr:`GlobalRestoreStatus.VALUE_SUSPENDED_FOR_USER_ACTION`
            * :attr:`GlobalRestoreStatus.VALUE_SUSPENDED`
            * :attr:`GlobalRestoreStatus.VALUE_ABORTED`
            
             Global rolled-up restore status value
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.description = description
        self.value = value
        VapiStruct.__init__(self)


GlobalRestoreStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.global_restore_status', {
        'description': type.OptionalType(type.StringType()),
        'value': type.OptionalType(type.StringType()),
    },
    GlobalRestoreStatus,
    False,
    None))



class GracefulRestartConfig(VapiStruct):
    """
    BGP Graceful Restart configuration parameters

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    GRACEFUL_RESTART_MODE_DISABLE = "DISABLE"
    """


    """
    GRACEFUL_RESTART_MODE_HELPER_ONLY = "HELPER_ONLY"
    """


    """
    GRACEFUL_RESTART_MODE_GR_AND_HELPER = "GR_AND_HELPER"
    """


    """



    _canonical_to_pep_names = {
                            'graceful_restart_mode': 'graceful_restart_mode',
                            'graceful_restart_timer': 'graceful_restart_timer',
                            }

    def __init__(self,
                 graceful_restart_mode=None,
                 graceful_restart_timer=None,
                ):
        """
        :type  graceful_restart_mode: :class:`str` or ``None``
        :param graceful_restart_mode: Possible values are: 
            
            * :attr:`GracefulRestartConfig.GRACEFUL_RESTART_MODE_DISABLE`
            * :attr:`GracefulRestartConfig.GRACEFUL_RESTART_MODE_HELPER_ONLY`
            * :attr:`GracefulRestartConfig.GRACEFUL_RESTART_MODE_GR_AND_HELPER`
            
             BGP Graceful Restart mode
        :type  graceful_restart_timer: :class:`GracefulRestartTimer` or ``None``
        :param graceful_restart_timer: Graceful Restart timers configuration
        """
        self.graceful_restart_mode = graceful_restart_mode
        self.graceful_restart_timer = graceful_restart_timer
        VapiStruct.__init__(self)


GracefulRestartConfig._set_binding_type(type.StructType(
    'com.vmware.nsx.model.graceful_restart_config', {
        'graceful_restart_mode': type.OptionalType(type.StringType()),
        'graceful_restart_timer': type.OptionalType(type.ReferenceType(__name__, 'GracefulRestartTimer')),
    },
    GracefulRestartConfig,
    False,
    None))



class GracefulRestartTimer(VapiStruct):
    """
    BGP Graceful Restart timers configuration

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'restart_timer': 'restart_timer',
                            'stale_timer': 'stale_timer',
                            }

    def __init__(self,
                 restart_timer=None,
                 stale_timer=None,
                ):
        """
        :type  restart_timer: :class:`long` or ``None``
        :param restart_timer: Maximum time BGP speaker will take for the BGP session to be
            re-established after a restart. Ranges from 1 sec to 3600 sec. This
            can be used to speed up routing convergence by its peer in case
            that the BGP speaker does not come back after a restart. If the
            session does not get re-established within the \"Restart Time\"
            that the Restarting Speaker advertised previously, the Receiving
            Speaker will delete all the stale routes from that peer. format:
            int64
        :type  stale_timer: :class:`long` or ``None``
        :param stale_timer: Maximum time before stale routes are removed from the RIB when the
            local BGP process restarts. Ranges from 1 sec to 3600 sec. format:
            int64
        """
        self.restart_timer = restart_timer
        self.stale_timer = stale_timer
        VapiStruct.__init__(self)


GracefulRestartTimer._set_binding_type(type.StructType(
    'com.vmware.nsx.model.graceful_restart_timer', {
        'restart_timer': type.OptionalType(type.IntegerType()),
        'stale_timer': type.OptionalType(type.IntegerType()),
    },
    GracefulRestartTimer,
    False,
    None))



class GraphConfiguration(VapiStruct):
    """
    Represents configuration of a graph widget

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "GraphConfiguration"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    SUB_TYPE_LINE_GRAPH = "LINE_GRAPH"
    """


    """
    SUB_TYPE_BAR_GRAPH = "BAR_GRAPH"
    """


    """
    SUB_TYPE_STACKED_BAR_GRAPH = "STACKED_BAR_GRAPH"
    """


    """



    _canonical_to_pep_names = {
                            'axes': 'axes',
                            'display_x_value': 'displayx_value',
                            'graphs': 'graphs',
                            'navigation': 'navigation',
                            'sub_type': 'sub_type',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'datasources': 'datasources',
                            'default_filter_value': 'default_filter_value',
                            'drilldown_id': 'drilldown_id',
                            'filter': 'filter',
                            'filter_value_required': 'filter_value_required',
                            'footer': 'footer',
                            'icons': 'icons',
                            'is_drilldown': 'is_drilldown',
                            'legend': 'legend',
                            'shared': 'shared',
                            'span': 'span',
                            'weight': 'weight',
                            }

    def __init__(self,
                 axes=None,
                 displayx_value=None,
                 graphs=None,
                 navigation=None,
                 sub_type=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='GraphConfiguration',
                 tags=None,
                 datasources=None,
                 default_filter_value=None,
                 drilldown_id=None,
                 filter=None,
                 filter_value_required=None,
                 footer=None,
                 icons=None,
                 is_drilldown=None,
                 legend=None,
                 shared=None,
                 span=None,
                 weight=None,
                ):
        """
        :type  axes: :class:`Axes` or ``None``
        :param axes: Axes of a graph
        :type  displayx_value: :class:`bool` or ``None``
        :param displayx_value: If true, value of a point is shown as label on X axis. If false,
            value of point is not shown as label on X axis. false can be useful
            in situations where there are too many points and showing the X
            value as label can clutter the X axis.
        :type  graphs: :class:`list` of :class:`GraphDefinition` or ``None``
        :param graphs: Graphs
        :type  navigation: :class:`str` or ``None``
        :param navigation: Hyperlink of the specified UI page that provides details.
        :type  sub_type: :class:`str` or ``None``
        :param sub_type: Possible values are: 
            
            * :attr:`GraphConfiguration.SUB_TYPE_LINE_GRAPH`
            * :attr:`GraphConfiguration.SUB_TYPE_BAR_GRAPH`
            * :attr:`GraphConfiguration.SUB_TYPE_STACKED_BAR_GRAPH`
            
            Describes the the type of graph. LINE_GRAPH shows a line graph
            chart BAR_GRAPH shows a simple bar graph chart STACKED_BAR_GRAPH
            shows a stacked bar graph chart
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Title of the widget. If display_name is omitted, the widget will be
            shown without a title.
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_LABELVALUECONFIGURATION`
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_DONUTCONFIGURATION`
            *
              :attr:`WidgetConfiguration.RESOURCE_TYPE_MULTIWIDGETCONFIGURATION`
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_CONTAINERCONFIGURATION`
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_STATSCONFIGURATION`
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_GRIDCONFIGURATION`
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_GRAPHCONFIGURATION`
            *
              :attr:`WidgetConfiguration.RESOURCE_TYPE_CUSTOMWIDGETCONFIGURATION`
            *
              :attr:`WidgetConfiguration.RESOURCE_TYPE_DROPDOWNFILTERWIDGETCONFIGURATION`
            
            Supported visualization types are LabelValueConfiguration,
            DonutConfiguration, GridConfiguration, StatsConfiguration,
            MultiWidgetConfiguration, GraphConfiguration,
            ContainerConfiguration, CustomWidgetConfiguration and
            DropdownFilterWidgetConfiguration.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  datasources: :class:`list` of :class:`Datasource` or ``None``
        :param datasources: The 'datasources' represent the sources from which data will be
            fetched. Currently, only NSX-API is supported as a 'default'
            datasource. An example of specifying 'default' datasource along
            with the urls to fetch data from is given at 'example_request'
            section of 'CreateWidgetConfiguration' API.
        :type  default_filter_value: :class:`list` of :class:`DefaultFilterValue` or ``None``
        :param default_filter_value: Default filter values to be passed to datasources. This will be
            used when the report is requested without filter values.
        :type  drilldown_id: :class:`str` or ``None``
        :param drilldown_id: Id of drilldown widget, if any. Id should be a valid id of an
            existing widget. A widget is considered as drilldown widget when it
            is associated with any other widget and provides more detailed
            information about any data item from the parent widget.
        :type  filter: :class:`str` or ``None``
        :param filter: Id of filter widget for subscription, if any. Id should be a valid
            id of an existing filter widget. Filter widget should be from the
            same view. Datasource URLs should have placeholder values equal to
            filter alias to accept the filter value on filter change.
        :type  filter_value_required: :class:`bool` or ``None``
        :param filter_value_required: Flag to indicate that widget will continue to work without filter
            value. If this flag is set to false then default_filter_value is
            manadatory.
        :type  footer: :class:`Footer` or ``None``
        :param footer: 
        :type  icons: :class:`list` of :class:`Icon` or ``None``
        :param icons: Icons to be applied at dashboard for widgets and UI elements.
        :type  is_drilldown: :class:`bool` or ``None``
        :param is_drilldown: Set to true if this widget should be used as a drilldown.
        :type  legend: :class:`Legend` or ``None``
        :param legend: Legend to be displayed. If legend is not needed, do not include it.
        :type  shared: :class:`bool` or ``None``
        :param shared: Please use the property 'shared' of View instead of this. The
            widgets of a shared view are visible to other users.
        :type  span: :class:`long` or ``None``
        :param span: Represents the horizontal span of the widget / container. format:
            int32
        :type  weight: :class:`long` or ``None``
        :param weight: Specify relavite weight in WidgetItem for placement in a view.
            Please see WidgetItem for details. format: int32
        """
        self.axes = axes
        self.displayx_value = displayx_value
        self.graphs = graphs
        self.navigation = navigation
        self.sub_type = sub_type
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        self.datasources = datasources
        self.default_filter_value = default_filter_value
        self.drilldown_id = drilldown_id
        self.filter = filter
        self.filter_value_required = filter_value_required
        self.footer = footer
        self.icons = icons
        self.is_drilldown = is_drilldown
        self.legend = legend
        self.shared = shared
        self.span = span
        self.weight = weight
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

GraphConfiguration._set_binding_type(type.StructType(
    'com.vmware.nsx.model.graph_configuration', {
        'axes': type.OptionalType(type.ReferenceType(__name__, 'Axes')),
        'display_x_value': type.OptionalType(type.BooleanType()),
        'graphs': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'GraphDefinition'))),
        'navigation': type.OptionalType(type.StringType()),
        'sub_type': type.OptionalType(type.StringType()),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'datasources': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Datasource'))),
        'default_filter_value': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'DefaultFilterValue'))),
        'drilldown_id': type.OptionalType(type.StringType()),
        'filter': type.OptionalType(type.StringType()),
        'filter_value_required': type.OptionalType(type.BooleanType()),
        'footer': type.OptionalType(type.ReferenceType(__name__, 'Footer')),
        'icons': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Icon'))),
        'is_drilldown': type.OptionalType(type.BooleanType()),
        'legend': type.OptionalType(type.ReferenceType(__name__, 'Legend')),
        'shared': type.OptionalType(type.BooleanType()),
        'span': type.OptionalType(type.IntegerType()),
        'weight': type.OptionalType(type.IntegerType()),
    },
    GraphConfiguration,
    False,
    None))



class GraphDefinition(VapiStruct):
    """
    Defines a graph

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'label': 'label',
                            'point_definition': 'point_definition',
                            'render_configuration': 'render_configuration',
                            }

    def __init__(self,
                 label=None,
                 point_definition=None,
                 render_configuration=None,
                ):
        """
        :type  label: :class:`Label` or ``None``
        :param label: Describes the graph. It labels the entities of graph. If the label
            is not provided then it is not shown for a graph. For example, for
            a single graph, the title of widget can describe the graph and a
            label may not be necessary to be shown.
        :type  point_definition: :class:`PointDefinition` or ``None``
        :param point_definition: Defines the points of a graph.
        :type  render_configuration: :class:`list` of :class:`RenderConfiguration` or ``None``
        :param render_configuration: Additional rendering or conditional evaluation of the field values
            to be performed, if any.
        """
        self.label = label
        self.point_definition = point_definition
        self.render_configuration = render_configuration
        VapiStruct.__init__(self)


GraphDefinition._set_binding_type(type.StructType(
    'com.vmware.nsx.model.graph_definition', {
        'label': type.OptionalType(type.ReferenceType(__name__, 'Label')),
        'point_definition': type.OptionalType(type.ReferenceType(__name__, 'PointDefinition')),
        'render_configuration': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'RenderConfiguration'))),
    },
    GraphDefinition,
    False,
    None))



class GridConfiguration(VapiStruct):
    """
    Represents configuration of a Grid or Table widget.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "GridConfiguration"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'columns': 'columns',
                            'page_size': 'page_size',
                            'row_list_fields': 'row_list_fields',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'datasources': 'datasources',
                            'default_filter_value': 'default_filter_value',
                            'drilldown_id': 'drilldown_id',
                            'filter': 'filter',
                            'filter_value_required': 'filter_value_required',
                            'footer': 'footer',
                            'icons': 'icons',
                            'is_drilldown': 'is_drilldown',
                            'legend': 'legend',
                            'shared': 'shared',
                            'span': 'span',
                            'weight': 'weight',
                            }

    def __init__(self,
                 columns=None,
                 page_size=None,
                 row_list_fields=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='GridConfiguration',
                 tags=None,
                 datasources=None,
                 default_filter_value=None,
                 drilldown_id=None,
                 filter=None,
                 filter_value_required=None,
                 footer=None,
                 icons=None,
                 is_drilldown=None,
                 legend=None,
                 shared=None,
                 span=None,
                 weight=None,
                ):
        """
        :type  columns: :class:`list` of :class:`ColumnItem` or ``None``
        :param columns: Array of columns of a Grid widget
        :type  page_size: :class:`long` or ``None``
        :param page_size: Number of records per page. page_size will be effective only when
            the urls provided in the datasource support paging. format: int32
        :type  row_list_fields: :class:`list` of :class:`RowListField` or ``None``
        :param row_list_fields: Rows of grid or table are formed from the list of objects returned
            by a row list field.
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Title of the widget. If display_name is omitted, the widget will be
            shown without a title.
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_LABELVALUECONFIGURATION`
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_DONUTCONFIGURATION`
            *
              :attr:`WidgetConfiguration.RESOURCE_TYPE_MULTIWIDGETCONFIGURATION`
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_CONTAINERCONFIGURATION`
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_STATSCONFIGURATION`
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_GRIDCONFIGURATION`
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_GRAPHCONFIGURATION`
            *
              :attr:`WidgetConfiguration.RESOURCE_TYPE_CUSTOMWIDGETCONFIGURATION`
            *
              :attr:`WidgetConfiguration.RESOURCE_TYPE_DROPDOWNFILTERWIDGETCONFIGURATION`
            
            Supported visualization types are LabelValueConfiguration,
            DonutConfiguration, GridConfiguration, StatsConfiguration,
            MultiWidgetConfiguration, GraphConfiguration,
            ContainerConfiguration, CustomWidgetConfiguration and
            DropdownFilterWidgetConfiguration.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  datasources: :class:`list` of :class:`Datasource` or ``None``
        :param datasources: The 'datasources' represent the sources from which data will be
            fetched. Currently, only NSX-API is supported as a 'default'
            datasource. An example of specifying 'default' datasource along
            with the urls to fetch data from is given at 'example_request'
            section of 'CreateWidgetConfiguration' API.
        :type  default_filter_value: :class:`list` of :class:`DefaultFilterValue` or ``None``
        :param default_filter_value: Default filter values to be passed to datasources. This will be
            used when the report is requested without filter values.
        :type  drilldown_id: :class:`str` or ``None``
        :param drilldown_id: Id of drilldown widget, if any. Id should be a valid id of an
            existing widget. A widget is considered as drilldown widget when it
            is associated with any other widget and provides more detailed
            information about any data item from the parent widget.
        :type  filter: :class:`str` or ``None``
        :param filter: Id of filter widget for subscription, if any. Id should be a valid
            id of an existing filter widget. Filter widget should be from the
            same view. Datasource URLs should have placeholder values equal to
            filter alias to accept the filter value on filter change.
        :type  filter_value_required: :class:`bool` or ``None``
        :param filter_value_required: Flag to indicate that widget will continue to work without filter
            value. If this flag is set to false then default_filter_value is
            manadatory.
        :type  footer: :class:`Footer` or ``None``
        :param footer: 
        :type  icons: :class:`list` of :class:`Icon` or ``None``
        :param icons: Icons to be applied at dashboard for widgets and UI elements.
        :type  is_drilldown: :class:`bool` or ``None``
        :param is_drilldown: Set to true if this widget should be used as a drilldown.
        :type  legend: :class:`Legend` or ``None``
        :param legend: Legend to be displayed. If legend is not needed, do not include it.
        :type  shared: :class:`bool` or ``None``
        :param shared: Please use the property 'shared' of View instead of this. The
            widgets of a shared view are visible to other users.
        :type  span: :class:`long` or ``None``
        :param span: Represents the horizontal span of the widget / container. format:
            int32
        :type  weight: :class:`long` or ``None``
        :param weight: Specify relavite weight in WidgetItem for placement in a view.
            Please see WidgetItem for details. format: int32
        """
        self.columns = columns
        self.page_size = page_size
        self.row_list_fields = row_list_fields
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        self.datasources = datasources
        self.default_filter_value = default_filter_value
        self.drilldown_id = drilldown_id
        self.filter = filter
        self.filter_value_required = filter_value_required
        self.footer = footer
        self.icons = icons
        self.is_drilldown = is_drilldown
        self.legend = legend
        self.shared = shared
        self.span = span
        self.weight = weight
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

GridConfiguration._set_binding_type(type.StructType(
    'com.vmware.nsx.model.grid_configuration', {
        'columns': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ColumnItem'))),
        'page_size': type.OptionalType(type.IntegerType()),
        'row_list_fields': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'RowListField'))),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'datasources': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Datasource'))),
        'default_filter_value': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'DefaultFilterValue'))),
        'drilldown_id': type.OptionalType(type.StringType()),
        'filter': type.OptionalType(type.StringType()),
        'filter_value_required': type.OptionalType(type.BooleanType()),
        'footer': type.OptionalType(type.ReferenceType(__name__, 'Footer')),
        'icons': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Icon'))),
        'is_drilldown': type.OptionalType(type.BooleanType()),
        'legend': type.OptionalType(type.ReferenceType(__name__, 'Legend')),
        'shared': type.OptionalType(type.BooleanType()),
        'span': type.OptionalType(type.IntegerType()),
        'weight': type.OptionalType(type.IntegerType()),
    },
    GridConfiguration,
    False,
    None))



class GroupedMigrationFeedbackRequest(VapiStruct):
    """
    Detailed feedback requests from the migration tool where user input is
    required.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'accepted_actions': 'accepted_actions',
                            'accepted_value_type': 'accepted_value_type',
                            'accepted_values': 'accepted_values',
                            'hash': 'hash',
                            'message': 'message',
                            'multi_value': 'multi_value',
                            'objects': 'objects',
                            'resolved': 'resolved',
                            'sub_vertical': 'sub_vertical',
                            'suggested_action': 'suggested_action',
                            'suggested_value': 'suggested_value',
                            'vertical': 'vertical',
                            }

    def __init__(self,
                 accepted_actions=None,
                 accepted_value_type=None,
                 accepted_values=None,
                 hash=None,
                 message=None,
                 multi_value=None,
                 objects=None,
                 resolved=None,
                 sub_vertical=None,
                 suggested_action=None,
                 suggested_value=None,
                 vertical=None,
                ):
        """
        :type  accepted_actions: :class:`list` of :class:`str` or ``None``
        :param accepted_actions: List of acceptable actions for this feedback request.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  accepted_value_type: :class:`str` or ``None``
        :param accepted_value_type: Data type of the items listed in acceptable values list.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  accepted_values: :class:`list` of :class:`str` or ``None``
        :param accepted_values: List of acceptable values for this feedback request.
        :type  hash: :class:`str` or ``None``
        :param hash: Identify a feedback request type across objects. This can be used
            to group together objects with similar feedback request and resolve
            them in one go.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  message: :class:`str` or ``None``
        :param message: Detailed feedback request with options.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  multi_value: :class:`bool` or ``None``
        :param multi_value: Indicates if multiple values can be selected as response from the
            list of acceptable value.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  objects: :class:`list` of :class:`SummaryMigrationFeedbackRequest` or ``None``
        :param objects: Collection of feedback requests of a given type
        :type  resolved: :class:`bool` or ``None``
        :param resolved: Indicates if a valid response already exist for all feedback
            requests in this group.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sub_vertical: :class:`str` or ``None``
        :param sub_vertical: Functional sub-area that this query falls into.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  suggested_action: :class:`str` or ``None``
        :param suggested_action: The suggested action to resolve this feedback request.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  suggested_value: :class:`str` or ``None``
        :param suggested_value: The suggested value to resolve this feedback request.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  vertical: :class:`str` or ``None``
        :param vertical: Functional area that this query falls into.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.accepted_actions = accepted_actions
        self.accepted_value_type = accepted_value_type
        self.accepted_values = accepted_values
        self.hash = hash
        self.message = message
        self.multi_value = multi_value
        self.objects = objects
        self.resolved = resolved
        self.sub_vertical = sub_vertical
        self.suggested_action = suggested_action
        self.suggested_value = suggested_value
        self.vertical = vertical
        VapiStruct.__init__(self)


GroupedMigrationFeedbackRequest._set_binding_type(type.StructType(
    'com.vmware.nsx.model.grouped_migration_feedback_request', {
        'accepted_actions': type.OptionalType(type.ListType(type.StringType())),
        'accepted_value_type': type.OptionalType(type.StringType()),
        'accepted_values': type.OptionalType(type.ListType(type.StringType())),
        'hash': type.OptionalType(type.StringType()),
        'message': type.OptionalType(type.StringType()),
        'multi_value': type.OptionalType(type.BooleanType()),
        'objects': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'SummaryMigrationFeedbackRequest'))),
        'resolved': type.OptionalType(type.BooleanType()),
        'sub_vertical': type.OptionalType(type.StringType()),
        'suggested_action': type.OptionalType(type.StringType()),
        'suggested_value': type.OptionalType(type.StringType()),
        'vertical': type.OptionalType(type.StringType()),
    },
    GroupedMigrationFeedbackRequest,
    False,
    None))



class GroupedMigrationFeedbackRequestListResult(VapiStruct):
    """
    Groups of detailed feedback requests from the migration tool where user
    input is required.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`GroupedMigrationFeedbackRequest` or ``None``
        :param results: Paged Collection of groups of feedback requests
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


GroupedMigrationFeedbackRequestListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.grouped_migration_feedback_request_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'GroupedMigrationFeedbackRequest'))),
    },
    GroupedMigrationFeedbackRequestListResult,
    False,
    None))



class GuestInfo(VapiStruct):
    """
    Guest virtual machine details include OS name and computer name of guest
    VM.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'computer_name': 'computer_name',
                            'os_name': 'os_name',
                            }

    def __init__(self,
                 computer_name=None,
                 os_name=None,
                ):
        """
        :type  computer_name: :class:`str` or ``None``
        :param computer_name: Computer name of guest virtual machine, which is set inside guest
            OS. Currently this is supported for guests on ESXi that have VMware
            Tools installed.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  os_name: :class:`str` or ``None``
        :param os_name: OS name of guest virtual machine. Currently this is supported for
            guests on ESXi that have VMware Tools installed.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.computer_name = computer_name
        self.os_name = os_name
        VapiStruct.__init__(self)


GuestInfo._set_binding_type(type.StructType(
    'com.vmware.nsx.model.guest_info', {
        'computer_name': type.OptionalType(type.StringType()),
        'os_name': type.OptionalType(type.StringType()),
    },
    GuestInfo,
    False,
    None))



class HaVipConfig(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'enabled': 'enabled',
                            'ha_vip_subnets': 'ha_vip_subnets',
                            'redundant_uplink_port_ids': 'redundant_uplink_port_ids',
                            }

    def __init__(self,
                 enabled=None,
                 ha_vip_subnets=None,
                 redundant_uplink_port_ids=None,
                ):
        """
        :type  enabled: :class:`bool` or ``None``
        :param enabled: Flag to enable this ha vip config.
        :type  ha_vip_subnets: :class:`list` of :class:`VIPSubnet` or ``None``
        :param ha_vip_subnets: Array of IP address subnets which will be used as floating IP
            addresses. | Note - this configuration is applicable only for
            Active-Standby LogicalRouter. | For Active-Active LogicalRouter
            this configuration will be rejected.
        :type  redundant_uplink_port_ids: :class:`list` of :class:`str` or ``None``
        :param redundant_uplink_port_ids: Identifiers of logical router uplink ports which are to be paired
            to provide | redundancy. Floating IP will be owned by one of these
            uplink ports (depending upon | which node is Active).
        """
        self.enabled = enabled
        self.ha_vip_subnets = ha_vip_subnets
        self.redundant_uplink_port_ids = redundant_uplink_port_ids
        VapiStruct.__init__(self)


HaVipConfig._set_binding_type(type.StructType(
    'com.vmware.nsx.model.ha_vip_config', {
        'enabled': type.OptionalType(type.BooleanType()),
        'ha_vip_subnets': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'VIPSubnet'))),
        'redundant_uplink_port_ids': type.OptionalType(type.ListType(type.StringType())),
    },
    HaVipConfig,
    False,
    None))



class Header(VapiStruct):
    """
    Header of a widget that provides additional information. This will be shown
    at the container level. It includes details as label value pairs.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    CONTENT_ALIGNMENT_LEFT = "LEFT"
    """


    """
    CONTENT_ALIGNMENT_RIGHT = "RIGHT"
    """


    """



    _canonical_to_pep_names = {
                            'condition': 'condition',
                            'content_alignment': 'content_alignment',
                            'sub_headers': 'sub_headers',
                            }

    def __init__(self,
                 condition=None,
                 content_alignment=None,
                 sub_headers=None,
                ):
        """
        :type  condition: :class:`str` or ``None``
        :param condition: If the condition is met then the header will be applied. Examples
            of expression syntax are provided under 'example_request' section
            of 'CreateWidgetConfiguration' API.
        :type  content_alignment: :class:`str` or ``None``
        :param content_alignment: Possible values are: 
            
            * :attr:`Header.CONTENT_ALIGNMENT_LEFT`
            * :attr:`Header.CONTENT_ALIGNMENT_RIGHT`
            
             Alignment of header labels.
        :type  sub_headers: :class:`list` of :class:`PropertyItem` or ``None``
        :param sub_headers: An array of label-value properties.
        """
        self.condition = condition
        self.content_alignment = content_alignment
        self.sub_headers = sub_headers
        VapiStruct.__init__(self)


Header._set_binding_type(type.StructType(
    'com.vmware.nsx.model.header', {
        'condition': type.OptionalType(type.StringType()),
        'content_alignment': type.OptionalType(type.StringType()),
        'sub_headers': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'PropertyItem'))),
    },
    Header,
    False,
    None))



class HealthCheckResult(VapiStruct):
    """
    Result of health check.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    VLAN_MTU_STATUS_TRUNKED = "TRUNKED"
    """


    """
    VLAN_MTU_STATUS_UNTRUNKED = "UNTRUNKED"
    """


    """
    VLAN_MTU_STATUS_UNKNOWN = "UNKNOWN"
    """


    """



    _canonical_to_pep_names = {
                            'results_per_transport_node': 'results_per_transport_node',
                            'updated_time': 'updated_time',
                            'vlan_mtu_status': 'vlan_mtu_status',
                            }

    def __init__(self,
                 results_per_transport_node=None,
                 updated_time=None,
                 vlan_mtu_status=None,
                ):
        """
        :type  results_per_transport_node: :class:`list` of :class:`HealthCheckResultPerTransportNode` or ``None``
        :param results_per_transport_node: List of health check results on specific transport node.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  updated_time: :class:`long` or ``None``
        :param updated_time: Timestamp of check result updated. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  vlan_mtu_status: :class:`str` or ``None``
        :param vlan_mtu_status: Possible values are: 
            
            * :attr:`HealthCheckResult.VLAN_MTU_STATUS_TRUNKED`
            * :attr:`HealthCheckResult.VLAN_MTU_STATUS_UNTRUNKED`
            * :attr:`HealthCheckResult.VLAN_MTU_STATUS_UNKNOWN`
            
             Overall status of VLAN-MTU health check result.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.results_per_transport_node = results_per_transport_node
        self.updated_time = updated_time
        self.vlan_mtu_status = vlan_mtu_status
        VapiStruct.__init__(self)


HealthCheckResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.health_check_result', {
        'results_per_transport_node': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'HealthCheckResultPerTransportNode'))),
        'updated_time': type.OptionalType(type.IntegerType()),
        'vlan_mtu_status': type.OptionalType(type.StringType()),
    },
    HealthCheckResult,
    False,
    None))



class HealthCheckResultOnHostSwitch(VapiStruct):
    """
    Health check result on specific host switch of specific transport node.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    VLAN_MTU_STATUS_TRUNKED = "TRUNKED"
    """


    """
    VLAN_MTU_STATUS_UNTRUNKED = "UNTRUNKED"
    """


    """
    VLAN_MTU_STATUS_UNKNOWN = "UNKNOWN"
    """


    """



    _canonical_to_pep_names = {
                            'host_switch_name': 'host_switch_name',
                            'results_per_uplink': 'results_per_uplink',
                            'updated_time': 'updated_time',
                            'vlan_mtu_status': 'vlan_mtu_status',
                            }

    def __init__(self,
                 host_switch_name=None,
                 results_per_uplink=None,
                 updated_time=None,
                 vlan_mtu_status=None,
                ):
        """
        :type  host_switch_name: :class:`str` or ``None``
        :param host_switch_name: Name of the host switch.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results_per_uplink: :class:`list` of :class:`HealthCheckResultPerUplink` or ``None``
        :param results_per_uplink: List of health check results per uplink on current host switch of
            specific transport node.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  updated_time: :class:`long` or ``None``
        :param updated_time: Timestamp of check result updated. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  vlan_mtu_status: :class:`str` or ``None``
        :param vlan_mtu_status: Possible values are: 
            
            * :attr:`HealthCheckResultOnHostSwitch.VLAN_MTU_STATUS_TRUNKED`
            * :attr:`HealthCheckResultOnHostSwitch.VLAN_MTU_STATUS_UNTRUNKED`
            * :attr:`HealthCheckResultOnHostSwitch.VLAN_MTU_STATUS_UNKNOWN`
            
             Status of VLAN-MTU health check result on host switch.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.host_switch_name = host_switch_name
        self.results_per_uplink = results_per_uplink
        self.updated_time = updated_time
        self.vlan_mtu_status = vlan_mtu_status
        VapiStruct.__init__(self)


HealthCheckResultOnHostSwitch._set_binding_type(type.StructType(
    'com.vmware.nsx.model.health_check_result_on_host_switch', {
        'host_switch_name': type.OptionalType(type.StringType()),
        'results_per_uplink': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'HealthCheckResultPerUplink'))),
        'updated_time': type.OptionalType(type.IntegerType()),
        'vlan_mtu_status': type.OptionalType(type.StringType()),
    },
    HealthCheckResultOnHostSwitch,
    False,
    None))



class HealthCheckResultPerTransportNode(VapiStruct):
    """
    Health check result on specific transport node

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'result_on_host_switch': 'result_on_host_switch',
                            'transport_node_id': 'transport_node_id',
                            }

    def __init__(self,
                 result_on_host_switch=None,
                 transport_node_id=None,
                ):
        """
        :type  result_on_host_switch: :class:`HealthCheckResultOnHostSwitch` or ``None``
        :param result_on_host_switch: 
        :type  transport_node_id: :class:`str` or ``None``
        :param transport_node_id: ID of the Transport Node.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.result_on_host_switch = result_on_host_switch
        self.transport_node_id = transport_node_id
        VapiStruct.__init__(self)


HealthCheckResultPerTransportNode._set_binding_type(type.StructType(
    'com.vmware.nsx.model.health_check_result_per_transport_node', {
        'result_on_host_switch': type.OptionalType(type.ReferenceType(__name__, 'HealthCheckResultOnHostSwitch')),
        'transport_node_id': type.OptionalType(type.StringType()),
    },
    HealthCheckResultPerTransportNode,
    False,
    None))



class HealthCheckResultPerUplink(VapiStruct):
    """
    Health check result for specific uplink.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'mtu_disallowed': 'mtu_disallowed',
                            'uplink_name': 'uplink_name',
                            'vlan_and_mtu_allowed': 'vlan_and_mtu_allowed',
                            'vlan_disallowed': 'vlan_disallowed',
                            }

    def __init__(self,
                 mtu_disallowed=None,
                 uplink_name=None,
                 vlan_and_mtu_allowed=None,
                 vlan_disallowed=None,
                ):
        """
        :type  mtu_disallowed: :class:`list` of :class:`HealthCheckVlanRange` or ``None``
        :param mtu_disallowed: List of VLAN ID ranges which are allowed by VLAN settings but may
            be disallowed by MTU settings.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  uplink_name: :class:`str` or ``None``
        :param uplink_name: Name of the uplink.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  vlan_and_mtu_allowed: :class:`list` of :class:`HealthCheckVlanRange` or ``None``
        :param vlan_and_mtu_allowed: List of VLAN ID ranges which are allowed by VLAN and MTU settings.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  vlan_disallowed: :class:`list` of :class:`HealthCheckVlanRange` or ``None``
        :param vlan_disallowed: List of VLAN ID ranges which may be disallowed by VLAN settings.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.mtu_disallowed = mtu_disallowed
        self.uplink_name = uplink_name
        self.vlan_and_mtu_allowed = vlan_and_mtu_allowed
        self.vlan_disallowed = vlan_disallowed
        VapiStruct.__init__(self)


HealthCheckResultPerUplink._set_binding_type(type.StructType(
    'com.vmware.nsx.model.health_check_result_per_uplink', {
        'mtu_disallowed': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'HealthCheckVlanRange'))),
        'uplink_name': type.OptionalType(type.StringType()),
        'vlan_and_mtu_allowed': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'HealthCheckVlanRange'))),
        'vlan_disallowed': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'HealthCheckVlanRange'))),
    },
    HealthCheckResultPerUplink,
    False,
    None))



class HealthCheckSpecVlans(VapiStruct):
    """
    HealthCheckSpecVlan is used for specifying VLAN ID ranges for healthcheck.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'vlan_ranges': 'vlan_ranges',
                            }

    def __init__(self,
                 vlan_ranges=None,
                ):
        """
        :type  vlan_ranges: :class:`list` of :class:`HealthCheckVlanRange` or ``None``
        :param vlan_ranges: VLAN ID ranges
        """
        self.vlan_ranges = vlan_ranges
        VapiStruct.__init__(self)


HealthCheckSpecVlans._set_binding_type(type.StructType(
    'com.vmware.nsx.model.health_check_spec_vlans', {
        'vlan_ranges': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'HealthCheckVlanRange'))),
    },
    HealthCheckSpecVlans,
    False,
    None))



class HealthCheckVlanRange(VapiStruct):
    """
    VLAN ID range

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'end': 'end',
                            'start': 'start',
                            }

    def __init__(self,
                 end=None,
                 start=None,
                ):
        """
        :type  end: :class:`long` or ``None``
        :param end: Virtual Local Area Network Identifier format: int64
        :type  start: :class:`long` or ``None``
        :param start: Virtual Local Area Network Identifier format: int64
        """
        self.end = end
        self.start = start
        VapiStruct.__init__(self)


HealthCheckVlanRange._set_binding_type(type.StructType(
    'com.vmware.nsx.model.health_check_vlan_range', {
        'end': type.OptionalType(type.IntegerType()),
        'start': type.OptionalType(type.IntegerType()),
    },
    HealthCheckVlanRange,
    False,
    None))



class HeatMapTransportNodesAggregateStatus(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'degraded_count': 'degraded_count',
                            'down_count': 'down_count',
                            'unknown_count': 'unknown_count',
                            'up_count': 'up_count',
                            }

    def __init__(self,
                 degraded_count=None,
                 down_count=None,
                 unknown_count=None,
                 up_count=None,
                ):
        """
        :type  degraded_count: :class:`long` or ``None``
        :param degraded_count: Number of transport nodes that are degraded format: int32
        :type  down_count: :class:`long` or ``None``
        :param down_count: Number of transport nodes that are down format: int32
        :type  unknown_count: :class:`long` or ``None``
        :param unknown_count: Number of transport nodes with unknown status format: int32
        :type  up_count: :class:`long` or ``None``
        :param up_count: Number of transport nodes that are up format: int32
        """
        self.degraded_count = degraded_count
        self.down_count = down_count
        self.unknown_count = unknown_count
        self.up_count = up_count
        VapiStruct.__init__(self)


HeatMapTransportNodesAggregateStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.heat_map_transport_nodes_aggregate_status', {
        'degraded_count': type.OptionalType(type.IntegerType()),
        'down_count': type.OptionalType(type.IntegerType()),
        'unknown_count': type.OptionalType(type.IntegerType()),
        'up_count': type.OptionalType(type.IntegerType()),
    },
    HeatMapTransportNodesAggregateStatus,
    False,
    None))



class HeatMapTransportZoneStatus(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'degraded_count': 'degraded_count',
                            'down_count': 'down_count',
                            'unknown_count': 'unknown_count',
                            'up_count': 'up_count',
                            }

    def __init__(self,
                 degraded_count=None,
                 down_count=None,
                 unknown_count=None,
                 up_count=None,
                ):
        """
        :type  degraded_count: :class:`long` or ``None``
        :param degraded_count: Number of transport nodes that are degraded format: int32
        :type  down_count: :class:`long` or ``None``
        :param down_count: Number of transport nodes that are down format: int32
        :type  unknown_count: :class:`long` or ``None``
        :param unknown_count: Number of transport nodes with unknown status format: int32
        :type  up_count: :class:`long` or ``None``
        :param up_count: Number of transport nodes that are up format: int32
        """
        self.degraded_count = degraded_count
        self.down_count = down_count
        self.unknown_count = unknown_count
        self.up_count = up_count
        VapiStruct.__init__(self)


HeatMapTransportZoneStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.heat_map_transport_zone_status', {
        'degraded_count': type.OptionalType(type.IntegerType()),
        'down_count': type.OptionalType(type.IntegerType()),
        'unknown_count': type.OptionalType(type.IntegerType()),
        'up_count': type.OptionalType(type.IntegerType()),
    },
    HeatMapTransportZoneStatus,
    False,
    None))



class HostInfraTrafficType(VapiStruct):
    """
    The traffic_name specifies the infrastructure traffic type and it must be
    one of the following system-defined types: FAULT_TOLERANCE is traffic for
    failover and recovery. HBR is traffic for Host based replication. ISCSI is
    traffic for Internet Small Computer System Interface. MANAGEMENT is traffic
    for host management. NFS is traffic related to file transfer in network
    file system. VDP is traffic for vSphere data protection. VIRTUAL_MACHINE is
    traffic generated by virtual machines. VMOTION is traffic for computing
    resource migration. VSAN is traffic generated by virtual storage area
    network. The dynamic_res_pool_name provides a name for the resource pool.
    It can be any arbitrary string. Either traffic_name or
    dynamic_res_pool_name must be set. If both are specified or omitted, an
    error will be returned.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    TRAFFIC_NAME_FAULT_TOLERANCE = "FAULT_TOLERANCE"
    """


    """
    TRAFFIC_NAME_HBR = "HBR"
    """


    """
    TRAFFIC_NAME_ISCSI = "ISCSI"
    """


    """
    TRAFFIC_NAME_MANAGEMENT = "MANAGEMENT"
    """


    """
    TRAFFIC_NAME_NFS = "NFS"
    """


    """
    TRAFFIC_NAME_VDP = "VDP"
    """


    """
    TRAFFIC_NAME_VIRTUAL_MACHINE = "VIRTUAL_MACHINE"
    """


    """
    TRAFFIC_NAME_VMOTION = "VMOTION"
    """


    """
    TRAFFIC_NAME_VSAN = "VSAN"
    """


    """



    _canonical_to_pep_names = {
                            'dynamic_res_pool_name': 'dynamic_res_pool_name',
                            'traffic_name': 'traffic_name',
                            }

    def __init__(self,
                 dynamic_res_pool_name=None,
                 traffic_name=None,
                ):
        """
        :type  dynamic_res_pool_name: :class:`str` or ``None``
        :param dynamic_res_pool_name: Dynamic resource pool traffic name
        :type  traffic_name: :class:`str` or ``None``
        :param traffic_name: Possible values are: 
            
            * :attr:`HostInfraTrafficType.TRAFFIC_NAME_FAULT_TOLERANCE`
            * :attr:`HostInfraTrafficType.TRAFFIC_NAME_HBR`
            * :attr:`HostInfraTrafficType.TRAFFIC_NAME_ISCSI`
            * :attr:`HostInfraTrafficType.TRAFFIC_NAME_MANAGEMENT`
            * :attr:`HostInfraTrafficType.TRAFFIC_NAME_NFS`
            * :attr:`HostInfraTrafficType.TRAFFIC_NAME_VDP`
            * :attr:`HostInfraTrafficType.TRAFFIC_NAME_VIRTUAL_MACHINE`
            * :attr:`HostInfraTrafficType.TRAFFIC_NAME_VMOTION`
            * :attr:`HostInfraTrafficType.TRAFFIC_NAME_VSAN`
            
             Traffic types
        """
        self.dynamic_res_pool_name = dynamic_res_pool_name
        self.traffic_name = traffic_name
        VapiStruct.__init__(self)


HostInfraTrafficType._set_binding_type(type.StructType(
    'com.vmware.nsx.model.host_infra_traffic_type', {
        'dynamic_res_pool_name': type.OptionalType(type.StringType()),
        'traffic_name': type.OptionalType(type.StringType()),
    },
    HostInfraTrafficType,
    False,
    None))



class HostNode(VapiStruct):
    """
    Host node

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "HostNode"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    MAINTENANCE_MODE_STATE_OFF = "OFF"
    """


    """
    MAINTENANCE_MODE_STATE_ENTERING = "ENTERING"
    """


    """
    MAINTENANCE_MODE_STATE_ON = "ON"
    """


    """
    OS_TYPE_ESXI = "ESXI"
    """


    """
    OS_TYPE_RHELKVM = "RHELKVM"
    """


    """
    OS_TYPE_RHELSERVER = "RHELSERVER"
    """


    """
    OS_TYPE_WINDOWSSERVER = "WINDOWSSERVER"
    """


    """
    OS_TYPE_RHELCONTAINER = "RHELCONTAINER"
    """


    """
    OS_TYPE_UBUNTUKVM = "UBUNTUKVM"
    """


    """
    OS_TYPE_UBUNTUSERVER = "UBUNTUSERVER"
    """


    """
    OS_TYPE_HYPERV = "HYPERV"
    """


    """
    OS_TYPE_CENTOSKVM = "CENTOSKVM"
    """


    """
    OS_TYPE_CENTOSSERVER = "CENTOSSERVER"
    """


    """
    OS_TYPE_CENTOSCONTAINER = "CENTOSCONTAINER"
    """


    """
    OS_TYPE_SLESKVM = "SLESKVM"
    """


    """
    OS_TYPE_SLESSERVER = "SLESSERVER"
    """


    """
    OS_TYPE_OELSERVER = "OELSERVER"
    """


    """



    _canonical_to_pep_names = {
                            'discovered_node_id': 'discovered_node_id',
                            'host_credential': 'host_credential',
                            'maintenance_mode_state': 'maintenance_mode_state',
                            'managed_by_server': 'managed_by_server',
                            'os_type': 'os_type',
                            'os_version': 'os_version',
                            'windows_install_location': 'windows_install_location',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'discovered_ip_addresses': 'discovered_ip_addresses',
                            'external_id': 'external_id',
                            'fqdn': 'fqdn',
                            'ip_addresses': 'ip_addresses',
                            }

    def __init__(self,
                 discovered_node_id=None,
                 host_credential=None,
                 maintenance_mode_state=None,
                 managed_by_server=None,
                 os_type=None,
                 os_version=None,
                 windows_install_location=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='HostNode',
                 tags=None,
                 discovered_ip_addresses=None,
                 external_id=None,
                 fqdn=None,
                 ip_addresses=None,
                ):
        """
        :type  discovered_node_id: :class:`str` or ``None``
        :param discovered_node_id: Id of discovered node which was converted to create this node
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  host_credential: :class:`HostNodeLoginCredential` or ``None``
        :param host_credential: Login credentials for the host. It is mandatory to provide
            credentials while adding host to MP to create transport node.
        :type  maintenance_mode_state: :class:`str` or ``None``
        :param maintenance_mode_state: Possible values are: 
            
            * :attr:`HostNode.MAINTENANCE_MODE_STATE_OFF`
            * :attr:`HostNode.MAINTENANCE_MODE_STATE_ENTERING`
            * :attr:`HostNode.MAINTENANCE_MODE_STATE_ON`
            
            Indicates host node's maintenance mode state. The state is ENTERING
            when a task to put the host in maintenance-mode is in progress.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  managed_by_server: :class:`str` or ``None``
        :param managed_by_server: The id of the vCenter server managing the ESXi type HostNode
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  os_type: :class:`str` or ``None``
        :param os_type: Possible values are: 
            
            * :attr:`HostNode.OS_TYPE_ESXI`
            * :attr:`HostNode.OS_TYPE_RHELKVM`
            * :attr:`HostNode.OS_TYPE_RHELSERVER`
            * :attr:`HostNode.OS_TYPE_WINDOWSSERVER`
            * :attr:`HostNode.OS_TYPE_RHELCONTAINER`
            * :attr:`HostNode.OS_TYPE_UBUNTUKVM`
            * :attr:`HostNode.OS_TYPE_UBUNTUSERVER`
            * :attr:`HostNode.OS_TYPE_HYPERV`
            * :attr:`HostNode.OS_TYPE_CENTOSKVM`
            * :attr:`HostNode.OS_TYPE_CENTOSSERVER`
            * :attr:`HostNode.OS_TYPE_CENTOSCONTAINER`
            * :attr:`HostNode.OS_TYPE_SLESKVM`
            * :attr:`HostNode.OS_TYPE_SLESSERVER`
            * :attr:`HostNode.OS_TYPE_OELSERVER`
            
             Hypervisor type, for example ESXi or RHEL KVM
        :type  os_version: :class:`str` or ``None``
        :param os_version: Version of the hypervisor operating system
        :type  windows_install_location: :class:`str` or ``None``
        :param windows_install_location: Specify an installation folder to install the NSX kernel modules
            for Windows Server. By default, it is C:\\Program
            Files\\VMware\\NSX\\.
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Fabric node type, for example 'HostNode', 'EdgeNode' or
            'PublicCloudGatewayNode'
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  discovered_ip_addresses: :class:`list` of :class:`str` or ``None``
        :param discovered_ip_addresses: Discovered IP Addresses of the fabric node, version 4 or 6 format:
            ip
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  external_id: :class:`str` or ``None``
        :param external_id: ID of the Node maintained on the Node and used to recognize the
            Node
        :type  fqdn: :class:`str` or ``None``
        :param fqdn: Fully qualified domain name of the fabric node
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  ip_addresses: :class:`list` of :class:`str` or ``None``
        :param ip_addresses: IP Addresses of the Node, version 4 or 6. This property is
            mandatory for all nodes except for automatic deployment of edge
            virtual machine node. For automatic deployment, the ip address from
            management_port_subnets property will be considered. format: ip
        """
        self.discovered_node_id = discovered_node_id
        self.host_credential = host_credential
        self.maintenance_mode_state = maintenance_mode_state
        self.managed_by_server = managed_by_server
        self.os_type = os_type
        self.os_version = os_version
        self.windows_install_location = windows_install_location
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        self.discovered_ip_addresses = discovered_ip_addresses
        self.external_id = external_id
        self.fqdn = fqdn
        self.ip_addresses = ip_addresses
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

HostNode._set_binding_type(type.StructType(
    'com.vmware.nsx.model.host_node', {
        'discovered_node_id': type.OptionalType(type.StringType()),
        'host_credential': type.OptionalType(type.ReferenceType(__name__, 'HostNodeLoginCredential')),
        'maintenance_mode_state': type.OptionalType(type.StringType()),
        'managed_by_server': type.OptionalType(type.StringType()),
        'os_type': type.OptionalType(type.StringType()),
        'os_version': type.OptionalType(type.StringType()),
        'windows_install_location': type.OptionalType(type.StringType()),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'discovered_ip_addresses': type.OptionalType(type.ListType(type.StringType())),
        'external_id': type.OptionalType(type.StringType()),
        'fqdn': type.OptionalType(type.StringType()),
        'ip_addresses': type.OptionalType(type.ListType(type.StringType())),
    },
    HostNode,
    False,
    None))



class HostNodeLoginCredential(VapiStruct):
    """
    The credentials to login into the host node

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'password': 'password',
                            'thumbprint': 'thumbprint',
                            'username': 'username',
                            }

    def __init__(self,
                 password=None,
                 thumbprint=None,
                 username=None,
                ):
        """
        :type  password: :class:`str` or ``None``
        :param password: The authentication password of the host node
        :type  thumbprint: :class:`str` or ``None``
        :param thumbprint: For ESXi hosts, the thumbprint of the ESXi management service. For
            KVM hosts, the SSH key fingerprint. If thumbprint is not provided
            then connection to host may not be established and API call will
            fail.
        :type  username: :class:`str` or ``None``
        :param username: The username of the account on the host node
        """
        self.password = password
        self.thumbprint = thumbprint
        self.username = username
        VapiStruct.__init__(self)


HostNodeLoginCredential._set_binding_type(type.StructType(
    'com.vmware.nsx.model.host_node_login_credential', {
        'password': type.OptionalType(type.StringType()),
        'thumbprint': type.OptionalType(type.StringType()),
        'username': type.OptionalType(type.StringType()),
    },
    HostNodeLoginCredential,
    False,
    None))



class HostNodeStatus(VapiStruct):
    """
    Host Node Status

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    CONFIG_STATUS_PENDING = "pending"
    """


    """
    CONFIG_STATUS_IN_PROGRESS = "in_progress"
    """


    """
    CONFIG_STATUS_SUCCESS = "success"
    """


    """
    CONFIG_STATUS_FAILED = "failed"
    """


    """
    CONFIG_STATUS_PARTIAL_SUCCESS = "partial_success"
    """


    """
    CONFIG_STATUS_ORPHANED = "orphaned"
    """


    """
    CONFIG_STATUS_UNKNOWN = "unknown"
    """


    """
    CONFIG_STATUS_ERROR = "error"
    """


    """
    DEPLOYMENT_STATUS_INSTALL_IN_PROGRESS = "INSTALL_IN_PROGRESS"
    """


    """
    DEPLOYMENT_STATUS_INSTALL_FAILED = "INSTALL_FAILED"
    """


    """
    DEPLOYMENT_STATUS_INSTALL_SUCCESSFUL = "INSTALL_SUCCESSFUL"
    """


    """
    DEPLOYMENT_STATUS_UNINSTALL_IN_PROGRESS = "UNINSTALL_IN_PROGRESS"
    """


    """
    DEPLOYMENT_STATUS_UNINSTALL_FAILED = "UNINSTALL_FAILED"
    """


    """
    DEPLOYMENT_STATUS_UNINSTALL_SUCCESSFUL = "UNINSTALL_SUCCESSFUL"
    """


    """
    DEPLOYMENT_STATUS_UNINSTALL_SCHEDULED = "UNINSTALL_SCHEDULED"
    """


    """
    DEPLOYMENT_STATUS_UPGRADE_IN_PROGRESS = "UPGRADE_IN_PROGRESS"
    """


    """
    DEPLOYMENT_STATUS_UPGRADE_FAILED = "UPGRADE_FAILED"
    """


    """
    DEPLOYMENT_STATUS_DEPLOYMENT_QUEUED = "DEPLOYMENT_QUEUED"
    """


    """
    DEPLOYMENT_STATUS_DEPLOYMENT_IN_PROGRESS = "DEPLOYMENT_IN_PROGRESS"
    """


    """
    DEPLOYMENT_STATUS_DEPLOYMENT_FAILED = "DEPLOYMENT_FAILED"
    """


    """
    DEPLOYMENT_STATUS_DEPLOYMENT_SUCCESSFUL = "DEPLOYMENT_SUCCESSFUL"
    """


    """
    DEPLOYMENT_STATUS_UNDEPLOYMENT_QUEUED = "UNDEPLOYMENT_QUEUED"
    """


    """
    DEPLOYMENT_STATUS_UNDEPLOYMENT_IN_PROGRESS = "UNDEPLOYMENT_IN_PROGRESS"
    """


    """
    DEPLOYMENT_STATUS_UNDEPLOYMENT_FAILED = "UNDEPLOYMENT_FAILED"
    """


    """
    DEPLOYMENT_STATUS_UNDEPLOYMENT_SUCCESSFUL = "UNDEPLOYMENT_SUCCESSFUL"
    """


    """
    DEPLOYMENT_STATUS_UPGRADE_QUEUED = "UPGRADE_QUEUED"
    """


    """
    DEPLOYMENT_STATUS_HOST_DISCONNECTED = "HOST_DISCONNECTED"
    """


    """
    DEPLOYMENT_STATUS_POWERED_OFF = "POWERED_OFF"
    """


    """



    _canonical_to_pep_names = {
                            'config_status': 'config_status',
                            'deployment_status': 'deployment_status',
                            'node_id': 'node_id',
                            }

    def __init__(self,
                 config_status=None,
                 deployment_status=None,
                 node_id=None,
                ):
        """
        :type  config_status: :class:`str` or ``None``
        :param config_status: Possible values are: 
            
            * :attr:`HostNodeStatus.CONFIG_STATUS_PENDING`
            * :attr:`HostNodeStatus.CONFIG_STATUS_IN_PROGRESS`
            * :attr:`HostNodeStatus.CONFIG_STATUS_SUCCESS`
            * :attr:`HostNodeStatus.CONFIG_STATUS_FAILED`
            * :attr:`HostNodeStatus.CONFIG_STATUS_PARTIAL_SUCCESS`
            * :attr:`HostNodeStatus.CONFIG_STATUS_ORPHANED`
            * :attr:`HostNodeStatus.CONFIG_STATUS_UNKNOWN`
            * :attr:`HostNodeStatus.CONFIG_STATUS_ERROR`
            
            Gives details of state of desired configuration. This property is
            available only if Tranport Node exists for the host. Following are
            the supported values pending - Transport Node configuration status
            is pending in_progress - Transport Node configuration status is in
            progress success - Transport Node configuration status is
            successful failed - Transport Node configuration status is failed
            partial_success - Transport Node configuration status is partial
            success orphaned - Transport Node configuration status is orphaned
            unknown - Transport Node configuration status is unknown error -
            Error occured during Transport Node configuration
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  deployment_status: :class:`str` or ``None``
        :param deployment_status: Possible values are: 
            
            * :attr:`HostNodeStatus.DEPLOYMENT_STATUS_INSTALL_IN_PROGRESS`
            * :attr:`HostNodeStatus.DEPLOYMENT_STATUS_INSTALL_FAILED`
            * :attr:`HostNodeStatus.DEPLOYMENT_STATUS_INSTALL_SUCCESSFUL`
            * :attr:`HostNodeStatus.DEPLOYMENT_STATUS_UNINSTALL_IN_PROGRESS`
            * :attr:`HostNodeStatus.DEPLOYMENT_STATUS_UNINSTALL_FAILED`
            * :attr:`HostNodeStatus.DEPLOYMENT_STATUS_UNINSTALL_SUCCESSFUL`
            * :attr:`HostNodeStatus.DEPLOYMENT_STATUS_UNINSTALL_SCHEDULED`
            * :attr:`HostNodeStatus.DEPLOYMENT_STATUS_UPGRADE_IN_PROGRESS`
            * :attr:`HostNodeStatus.DEPLOYMENT_STATUS_UPGRADE_FAILED`
            * :attr:`HostNodeStatus.DEPLOYMENT_STATUS_DEPLOYMENT_QUEUED`
            * :attr:`HostNodeStatus.DEPLOYMENT_STATUS_DEPLOYMENT_IN_PROGRESS`
            * :attr:`HostNodeStatus.DEPLOYMENT_STATUS_DEPLOYMENT_FAILED`
            * :attr:`HostNodeStatus.DEPLOYMENT_STATUS_DEPLOYMENT_SUCCESSFUL`
            * :attr:`HostNodeStatus.DEPLOYMENT_STATUS_UNDEPLOYMENT_QUEUED`
            * :attr:`HostNodeStatus.DEPLOYMENT_STATUS_UNDEPLOYMENT_IN_PROGRESS`
            * :attr:`HostNodeStatus.DEPLOYMENT_STATUS_UNDEPLOYMENT_FAILED`
            * :attr:`HostNodeStatus.DEPLOYMENT_STATUS_UNDEPLOYMENT_SUCCESSFUL`
            * :attr:`HostNodeStatus.DEPLOYMENT_STATUS_UPGRADE_QUEUED`
            * :attr:`HostNodeStatus.DEPLOYMENT_STATUS_HOST_DISCONNECTED`
            * :attr:`HostNodeStatus.DEPLOYMENT_STATUS_POWERED_OFF`
            
            This specifies the current nsx install status for host node.
            Following are the supported values INSTALL_IN_PROGRESS - NSX
            installation is in progress on the host INSTALL_FAILED - NSX
            installation failed on the host INSTALL_SUCCESSFUL - NSX
            installation successful on the host UNINSTALL_IN_PROGRESS - NSX
            uninstallation in progress on the host UNINSTALL_FAILED - NSX
            uninstallation failed on the host UNINSTALL_SUCCESSFUL - NSX
            uninstallation successful on the host UNINSTALL_SCHEDULED - NSX
            uninstallation is scheduled on the host UPGRADE_IN_PROGRESS - NSX
            upgrade is in progress on the host UPGRADE_FAILED - NSX upgrade
            failed on the host DEPLOYMENT_QUEUED - Deployment is queued on the
            DEPLOYMENT_IN_PROGRESS - Deployment is in progress
            DEPLOYMENT_FAILED - Deployment is failed DEPLOYMENT_SUCCESSFUL -
            Deployment is successful UNDEPLOYMENT_QUEUED - Undeployment is
            queued UNDEPLOYMENT_IN_PROGRESS - Undeployment is in progress
            UNDEPLOYMENT_FAILED - Undeployment failed UNDEPLOYMENT_SUCCESSFUL -
            Undeployment is successful UPGRADE_QUEUED - Upgrade is queued
            HOST_DISCONNECTED - Host is disconnected POWERED_OFF - Host is
            powered off
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  node_id: :class:`str` or ``None``
        :param node_id: Unique Id of the host node
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.config_status = config_status
        self.deployment_status = deployment_status
        self.node_id = node_id
        VapiStruct.__init__(self)


HostNodeStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.host_node_status', {
        'config_status': type.OptionalType(type.StringType()),
        'deployment_status': type.OptionalType(type.StringType()),
        'node_id': type.OptionalType(type.StringType()),
    },
    HostNodeStatus,
    False,
    None))



class HostNodeStatusListResult(VapiStruct):
    """
    HostNodeStatus queries result

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`HostNodeStatus` or ``None``
        :param results: HostNodeStatus Results
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


HostNodeStatusListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.host_node_status_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'HostNodeStatus'))),
    },
    HostNodeStatusListResult,
    False,
    None))



class HostSwitchInfo(VapiStruct):
    """
    Information of host switch participating in transport zone

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    HOST_SWITCH_MODE_STANDARD = "STANDARD"
    """


    """
    HOST_SWITCH_MODE_ENS = "ENS"
    """


    """
    HOST_SWITCH_MODE_ENS_INTERRUPT = "ENS_INTERRUPT"
    """


    """
    HOST_SWITCH_TYPE_NVDS = "NVDS"
    """


    """
    HOST_SWITCH_TYPE_VDS = "VDS"
    """


    """



    _canonical_to_pep_names = {
                            'host_switch_id': 'host_switch_id',
                            'host_switch_mode': 'host_switch_mode',
                            'host_switch_name': 'host_switch_name',
                            'host_switch_type': 'host_switch_type',
                            }

    def __init__(self,
                 host_switch_id=None,
                 host_switch_mode=None,
                 host_switch_name=None,
                 host_switch_type=None,
                ):
        """
        :type  host_switch_id: :class:`str` or ``None``
        :param host_switch_id: Unique ID of a host switch
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  host_switch_mode: :class:`str` or ``None``
        :param host_switch_mode: Possible values are: 
            
            * :attr:`HostSwitchInfo.HOST_SWITCH_MODE_STANDARD`
            * :attr:`HostSwitchInfo.HOST_SWITCH_MODE_ENS`
            * :attr:`HostSwitchInfo.HOST_SWITCH_MODE_ENS_INTERRUPT`
            
             Mode of host switch
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  host_switch_name: :class:`str` or ``None``
        :param host_switch_name: Name of a host switch
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  host_switch_type: :class:`str` or ``None``
        :param host_switch_type: Possible values are: 
            
            * :attr:`HostSwitchInfo.HOST_SWITCH_TYPE_NVDS`
            * :attr:`HostSwitchInfo.HOST_SWITCH_TYPE_VDS`
            
             Type of a host switch
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.host_switch_id = host_switch_id
        self.host_switch_mode = host_switch_mode
        self.host_switch_name = host_switch_name
        self.host_switch_type = host_switch_type
        VapiStruct.__init__(self)


HostSwitchInfo._set_binding_type(type.StructType(
    'com.vmware.nsx.model.host_switch_info', {
        'host_switch_id': type.OptionalType(type.StringType()),
        'host_switch_mode': type.OptionalType(type.StringType()),
        'host_switch_name': type.OptionalType(type.StringType()),
        'host_switch_type': type.OptionalType(type.StringType()),
    },
    HostSwitchInfo,
    False,
    None))



class HostSwitchProfileTypeIdEntry(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    KEY_UPLINKHOSTSWITCHPROFILE = "UplinkHostSwitchProfile"
    """


    """
    KEY_LLDPHOSTSWITCHPROFILE = "LldpHostSwitchProfile"
    """


    """
    KEY_NIOCPROFILE = "NiocProfile"
    """


    """
    KEY_EXTRACONFIGHOSTSWITCHPROFILE = "ExtraConfigHostSwitchProfile"
    """


    """



    _canonical_to_pep_names = {
                            'key': 'key',
                            'value': 'value',
                            }

    def __init__(self,
                 key=None,
                 value=None,
                ):
        """
        :type  key: :class:`str` or ``None``
        :param key: Possible values are: 
            
            * :attr:`HostSwitchProfileTypeIdEntry.KEY_UPLINKHOSTSWITCHPROFILE`
            * :attr:`HostSwitchProfileTypeIdEntry.KEY_LLDPHOSTSWITCHPROFILE`
            * :attr:`HostSwitchProfileTypeIdEntry.KEY_NIOCPROFILE`
            *
              :attr:`HostSwitchProfileTypeIdEntry.KEY_EXTRACONFIGHOSTSWITCHPROFILE`
            
             Supported HostSwitch profiles.
        :type  value: :class:`str` or ``None``
        :param value: key value
        """
        self.key = key
        self.value = value
        VapiStruct.__init__(self)


HostSwitchProfileTypeIdEntry._set_binding_type(type.StructType(
    'com.vmware.nsx.model.host_switch_profile_type_id_entry', {
        'key': type.OptionalType(type.StringType()),
        'value': type.OptionalType(type.StringType()),
    },
    HostSwitchProfileTypeIdEntry,
    False,
    None))



class HostSwitchProfilesListResult(VapiStruct):
    """
    HostSwitch Profile queries result

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param results: HostSwitch Profile Results
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`BaseHostSwitchProfile`. When methods return a value of this
            class as a return value, the attribute will contain all the
            attributes defined in :class:`BaseHostSwitchProfile`.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


HostSwitchProfilesListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.host_switch_profiles_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'BaseHostSwitchProfile')]))),
    },
    HostSwitchProfilesListResult,
    False,
    None))



class HostSwitchSpec(VapiStruct):
    """
    The HostSwitchSpec is the base class for standard and preconfigured host
    switch specifications.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "HostSwitchSpec"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    RESOURCE_TYPE_STANDARDHOSTSWITCHSPEC = "StandardHostSwitchSpec"
    """


    """
    RESOURCE_TYPE_PRECONFIGUREDHOSTSWITCHSPEC = "PreconfiguredHostSwitchSpec"
    """


    """



    _canonical_to_pep_names = {
                            'resource_type': 'resource_type',
                            }

    def __init__(self,
                 resource_type='HostSwitchSpec',
                ):
        """
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`HostSwitchSpec.RESOURCE_TYPE_STANDARDHOSTSWITCHSPEC`
            * :attr:`HostSwitchSpec.RESOURCE_TYPE_PRECONFIGUREDHOSTSWITCHSPEC`
        """
        self._resource_type = resource_type
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

HostSwitchSpec._set_binding_type(type.StructType(
    'com.vmware.nsx.model.host_switch_spec', {
        'resource_type': type.StringType(),
    },
    HostSwitchSpec,
    False,
    None))



class HostSwitchState(VapiStruct):
    """
    Host Switch State

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    HOST_SWITCH_TYPE_NVDS = "NVDS"
    """


    """
    HOST_SWITCH_TYPE_VDS = "VDS"
    """


    """



    _canonical_to_pep_names = {
                            'endpoints': 'endpoints',
                            'host_switch_id': 'host_switch_id',
                            'host_switch_name': 'host_switch_name',
                            'host_switch_type': 'host_switch_type',
                            'transport_zone_ids': 'transport_zone_ids',
                            }

    def __init__(self,
                 endpoints=None,
                 host_switch_id=None,
                 host_switch_name=None,
                 host_switch_type=None,
                 transport_zone_ids=None,
                ):
        """
        :type  endpoints: :class:`list` of :class:`Endpoint` or ``None``
        :param endpoints: List of virtual tunnel endpoints which are configured on this
            switch
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  host_switch_id: :class:`str` or ``None``
        :param host_switch_id: External ID of the HostSwitch
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  host_switch_name: :class:`str` or ``None``
        :param host_switch_name: The name must be unique among all host switches specified in a
            given Transport Node.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  host_switch_type: :class:`str` or ``None``
        :param host_switch_type: Possible values are: 
            
            * :attr:`HostSwitchState.HOST_SWITCH_TYPE_NVDS`
            * :attr:`HostSwitchState.HOST_SWITCH_TYPE_VDS`
            
            VDS represents VMware vSphere Distributed Switch from vSphere that
            is used as HostSwitch through TransportNode or TransportNodeProfile
            configuration. When VDS is used as a HostSwitch, Hosts have to be
            added to VDS from vSphere and VDS instance is created on Hosts. To
            configure NSX on such hosts, you can use this VDS as a HostSwitch
            from NSX manager. vCenter has the ownership of MTU, LAG, NIOC and
            LLDP configuration of such VDS backed HostSwitch. Remaining
            configuration (e.g. UplinkHostswitchProfile) will be managed by
            NSX. NVDS represents NSX Virtual Switch which is NSX native
            HostSwitch. All configurations of NVDS will be managed by NSX.
        :type  transport_zone_ids: :class:`list` of :class:`str` or ``None``
        :param transport_zone_ids: List of Ids of TransportZones this HostSwitch belongs to
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.endpoints = endpoints
        self.host_switch_id = host_switch_id
        self.host_switch_name = host_switch_name
        self.host_switch_type = host_switch_type
        self.transport_zone_ids = transport_zone_ids
        VapiStruct.__init__(self)


HostSwitchState._set_binding_type(type.StructType(
    'com.vmware.nsx.model.host_switch_state', {
        'endpoints': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Endpoint'))),
        'host_switch_id': type.OptionalType(type.StringType()),
        'host_switch_name': type.OptionalType(type.StringType()),
        'host_switch_type': type.OptionalType(type.StringType()),
        'transport_zone_ids': type.OptionalType(type.ListType(type.StringType())),
    },
    HostSwitchState,
    False,
    None))



class HostUpgradeStatus(VapiStruct):
    """
    Status of host upgrade

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATUS_SUCCESS = "SUCCESS"
    """


    """
    STATUS_FAILED = "FAILED"
    """


    """
    STATUS_IN_PROGRESS = "IN_PROGRESS"
    """


    """
    STATUS_NOT_STARTED = "NOT_STARTED"
    """


    """
    STATUS_PAUSING = "PAUSING"
    """


    """
    STATUS_PAUSED = "PAUSED"
    """


    """



    _canonical_to_pep_names = {
                            'can_skip': 'can_skip',
                            'component_type': 'component_type',
                            'current_version_node_summary': 'current_version_node_summary',
                            'details': 'details',
                            'node_count_at_target_version': 'node_count_at_target_version',
                            'percent_complete': 'percent_complete',
                            'pre_upgrade_status': 'pre_upgrade_status',
                            'status': 'status',
                            'target_component_version': 'target_component_version',
                            }

    def __init__(self,
                 can_skip=None,
                 component_type=None,
                 current_version_node_summary=None,
                 details=None,
                 node_count_at_target_version=None,
                 percent_complete=None,
                 pre_upgrade_status=None,
                 status=None,
                 target_component_version=None,
                ):
        """
        :type  can_skip: :class:`bool` or ``None``
        :param can_skip: Can the upgrade of the remaining units in this component be skipped
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  component_type: :class:`str` or ``None``
        :param component_type: Component type for the upgrade status
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  current_version_node_summary: :class:`NodeSummaryList` or ``None``
        :param current_version_node_summary: Mapping of current versions of nodes and counts of nodes at the
            respective versions.
        :type  details: :class:`str` or ``None``
        :param details: Details about the upgrade status
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  node_count_at_target_version: :class:`long` or ``None``
        :param node_count_at_target_version: Number of nodes of the type and at the component version format:
            int32
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  percent_complete: :class:`float` or ``None``
        :param percent_complete: Indicator of upgrade progress in percentage
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  pre_upgrade_status: :class:`UpgradeChecksExecutionStatus` or ``None``
        :param pre_upgrade_status: Pre-upgrade status of the component-type
        :type  status: :class:`str` or ``None``
        :param status: Possible values are: 
            
            * :attr:`HostUpgradeStatus.STATUS_SUCCESS`
            * :attr:`HostUpgradeStatus.STATUS_FAILED`
            * :attr:`HostUpgradeStatus.STATUS_IN_PROGRESS`
            * :attr:`HostUpgradeStatus.STATUS_NOT_STARTED`
            * :attr:`HostUpgradeStatus.STATUS_PAUSING`
            * :attr:`HostUpgradeStatus.STATUS_PAUSED`
            
             Upgrade status of component
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  target_component_version: :class:`str` or ``None``
        :param target_component_version: Target component version
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.can_skip = can_skip
        self.component_type = component_type
        self.current_version_node_summary = current_version_node_summary
        self.details = details
        self.node_count_at_target_version = node_count_at_target_version
        self.percent_complete = percent_complete
        self.pre_upgrade_status = pre_upgrade_status
        self.status = status
        self.target_component_version = target_component_version
        VapiStruct.__init__(self)


HostUpgradeStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.host_upgrade_status', {
        'can_skip': type.OptionalType(type.BooleanType()),
        'component_type': type.OptionalType(type.StringType()),
        'current_version_node_summary': type.OptionalType(type.ReferenceType(__name__, 'NodeSummaryList')),
        'details': type.OptionalType(type.StringType()),
        'node_count_at_target_version': type.OptionalType(type.IntegerType()),
        'percent_complete': type.OptionalType(type.DoubleType()),
        'pre_upgrade_status': type.OptionalType(type.ReferenceType(__name__, 'UpgradeChecksExecutionStatus')),
        'status': type.OptionalType(type.StringType()),
        'target_component_version': type.OptionalType(type.StringType()),
    },
    HostUpgradeStatus,
    False,
    None))



class HostedEntityInfo(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'entity_type': 'entity_type',
                            'entity_uuid': 'entity_uuid',
                            }

    def __init__(self,
                 entity_type=None,
                 entity_uuid=None,
                ):
        """
        :type  entity_type: :class:`str` or ``None``
        :param entity_type: The type of entity hosted could be MP, CCP, VMC App etc.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  entity_uuid: :class:`str` or ``None``
        :param entity_uuid: Unique identifier of entity
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.entity_type = entity_type
        self.entity_uuid = entity_uuid
        VapiStruct.__init__(self)


HostedEntityInfo._set_binding_type(type.StructType(
    'com.vmware.nsx.model.hosted_entity_info', {
        'entity_type': type.OptionalType(type.StringType()),
        'entity_uuid': type.OptionalType(type.StringType()),
    },
    HostedEntityInfo,
    False,
    None))



class HttpProtocol(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "HttpProtocol"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'authentication_scheme': 'authentication_scheme',
                            'name': 'name',
                            }

    def __init__(self,
                 authentication_scheme=None,
                 name='HttpProtocol',
                ):
        """
        :type  authentication_scheme: :class:`BasicAuthenticationScheme` or ``None``
        :param authentication_scheme: Scheme to authenticate if required
        :type  name: :class:`str`
        :param name: Possible values are: 
            
            * :attr:`Protocol.NAME_HTTP`
            * :attr:`Protocol.NAME_HTTPS`
            * :attr:`Protocol.NAME_SCP`
            * :attr:`Protocol.NAME_SFTP`
            
             Protocol name
        """
        self.authentication_scheme = authentication_scheme
        self._name = name
        VapiStruct.__init__(self)

    @property
    def name(self):
        """
        Return the discriminator value
        """
        return self._name

HttpProtocol._set_binding_type(type.StructType(
    'com.vmware.nsx.model.http_protocol', {
        'authentication_scheme': type.OptionalType(type.ReferenceType(__name__, 'BasicAuthenticationScheme')),
        'name': type.StringType(),
    },
    HttpProtocol,
    False,
    None))



class HttpServiceProperties(VapiStruct):
    """
    HTTP Service properties

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    LOGGING_LEVEL_OFF = "OFF"
    """


    """
    LOGGING_LEVEL_FATAL = "FATAL"
    """


    """
    LOGGING_LEVEL_ERROR = "ERROR"
    """


    """
    LOGGING_LEVEL_WARN = "WARN"
    """


    """
    LOGGING_LEVEL_INFO = "INFO"
    """


    """
    LOGGING_LEVEL_DEBUG = "DEBUG"
    """


    """
    LOGGING_LEVEL_TRACE = "TRACE"
    """


    """



    _canonical_to_pep_names = {
                            'basic_authentication_enabled': 'basic_authentication_enabled',
                            'certificate': 'certificate',
                            'cipher_suites': 'cipher_suites',
                            'client_api_concurrency_limit': 'client_api_concurrency_limit',
                            'client_api_rate_limit': 'client_api_rate_limit',
                            'connection_timeout': 'connection_timeout',
                            'cookie_based_authentication_enabled': 'cookie_based_authentication_enabled',
                            'global_api_concurrency_limit': 'global_api_concurrency_limit',
                            'logging_level': 'logging_level',
                            'protocol_versions': 'protocol_versions',
                            'redirect_host': 'redirect_host',
                            'session_timeout': 'session_timeout',
                            }

    def __init__(self,
                 basic_authentication_enabled=None,
                 certificate=None,
                 cipher_suites=None,
                 client_api_concurrency_limit=None,
                 client_api_rate_limit=None,
                 connection_timeout=None,
                 cookie_based_authentication_enabled=None,
                 global_api_concurrency_limit=None,
                 logging_level=None,
                 protocol_versions=None,
                 redirect_host=None,
                 session_timeout=None,
                ):
        """
        :type  basic_authentication_enabled: :class:`bool` or ``None``
        :param basic_authentication_enabled: Identifies whether basic authentication is enabled or disabled in
            API calls.
        :type  certificate: :class:`Certificate` or ``None``
        :param certificate: 
        :type  cipher_suites: :class:`list` of :class:`CipherSuite` or ``None``
        :param cipher_suites: Cipher suites used to secure contents of connection
        :type  client_api_concurrency_limit: :class:`long` or ``None``
        :param client_api_concurrency_limit: The maximum number of concurrent API requests that will be serviced
            for a given authenticated client. If the number of API requests
            being processed exceeds this limit, new API requests will be
            refused and a 503 Service Unavailable response will be returned to
            the client. To disable API concurrency limiting, set this value to
            0. format: int64
        :type  client_api_rate_limit: :class:`long` or ``None``
        :param client_api_rate_limit: The maximum number of API requests that will be serviced per second
            for a given authenticated client. If more API requests are received
            than can be serviced, a 429 Too Many Requests HTTP response will be
            returned. To disable API rate limiting, set this value to 0.
            format: int64
        :type  connection_timeout: :class:`long` or ``None``
        :param connection_timeout: NSX connection timeout, set to 0 to configure no timeout format:
            int64
        :type  cookie_based_authentication_enabled: :class:`bool` or ``None``
        :param cookie_based_authentication_enabled: Identifies whether cookie-based authentication is enabled or
            disabled in API calls. When cookie-based authentication is
            disabled, new sessions cannot be created via /api/session/create.
        :type  global_api_concurrency_limit: :class:`long` or ``None``
        :param global_api_concurrency_limit: The maximum number of concurrent API requests that will be
            serviced. If the number of API requests being processed exceeds
            this limit, new API requests will be refused and a 503 Service
            Unavailable response will be returned to the client. To disable API
            concurrency limiting, set this value to 0. format: int64
        :type  logging_level: :class:`str` or ``None``
        :param logging_level: Possible values are: 
            
            * :attr:`HttpServiceProperties.LOGGING_LEVEL_OFF`
            * :attr:`HttpServiceProperties.LOGGING_LEVEL_FATAL`
            * :attr:`HttpServiceProperties.LOGGING_LEVEL_ERROR`
            * :attr:`HttpServiceProperties.LOGGING_LEVEL_WARN`
            * :attr:`HttpServiceProperties.LOGGING_LEVEL_INFO`
            * :attr:`HttpServiceProperties.LOGGING_LEVEL_DEBUG`
            * :attr:`HttpServiceProperties.LOGGING_LEVEL_TRACE`
            
             Service logging level
        :type  protocol_versions: :class:`list` of :class:`ProtocolVersion` or ``None``
        :param protocol_versions: TLS protocol versions
        :type  redirect_host: :class:`str` or ``None``
        :param redirect_host: Host name or IP address to use for redirect location headers, or
            empty string to derive from current request
        :type  session_timeout: :class:`long` or ``None``
        :param session_timeout: NSX session inactivity timeout, set to 0 to configure no timeout
            format: int64
        """
        self.basic_authentication_enabled = basic_authentication_enabled
        self.certificate = certificate
        self.cipher_suites = cipher_suites
        self.client_api_concurrency_limit = client_api_concurrency_limit
        self.client_api_rate_limit = client_api_rate_limit
        self.connection_timeout = connection_timeout
        self.cookie_based_authentication_enabled = cookie_based_authentication_enabled
        self.global_api_concurrency_limit = global_api_concurrency_limit
        self.logging_level = logging_level
        self.protocol_versions = protocol_versions
        self.redirect_host = redirect_host
        self.session_timeout = session_timeout
        VapiStruct.__init__(self)


HttpServiceProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.http_service_properties', {
        'basic_authentication_enabled': type.OptionalType(type.BooleanType()),
        'certificate': type.OptionalType(type.ReferenceType(__name__, 'Certificate')),
        'cipher_suites': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'CipherSuite'))),
        'client_api_concurrency_limit': type.OptionalType(type.IntegerType()),
        'client_api_rate_limit': type.OptionalType(type.IntegerType()),
        'connection_timeout': type.OptionalType(type.IntegerType()),
        'cookie_based_authentication_enabled': type.OptionalType(type.BooleanType()),
        'global_api_concurrency_limit': type.OptionalType(type.IntegerType()),
        'logging_level': type.OptionalType(type.StringType()),
        'protocol_versions': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ProtocolVersion'))),
        'redirect_host': type.OptionalType(type.StringType()),
        'session_timeout': type.OptionalType(type.IntegerType()),
    },
    HttpServiceProperties,
    False,
    None))



class HttpsProtocol(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "HttpsProtocol"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'authentication_scheme': 'authentication_scheme',
                            'sha256_thumbprint': 'sha256_thumbprint',
                            'name': 'name',
                            }

    def __init__(self,
                 authentication_scheme=None,
                 sha256_thumbprint=None,
                 name='HttpsProtocol',
                ):
        """
        :type  authentication_scheme: :class:`BasicAuthenticationScheme` or ``None``
        :param authentication_scheme: Scheme to authenticate if required
        :type  sha256_thumbprint: :class:`str` or ``None``
        :param sha256_thumbprint: SSL thumbprint of server
        :type  name: :class:`str`
        :param name: Possible values are: 
            
            * :attr:`Protocol.NAME_HTTP`
            * :attr:`Protocol.NAME_HTTPS`
            * :attr:`Protocol.NAME_SCP`
            * :attr:`Protocol.NAME_SFTP`
            
             Protocol name
        """
        self.authentication_scheme = authentication_scheme
        self.sha256_thumbprint = sha256_thumbprint
        self._name = name
        VapiStruct.__init__(self)

    @property
    def name(self):
        """
        Return the discriminator value
        """
        return self._name

HttpsProtocol._set_binding_type(type.StructType(
    'com.vmware.nsx.model.https_protocol', {
        'authentication_scheme': type.OptionalType(type.ReferenceType(__name__, 'BasicAuthenticationScheme')),
        'sha256_thumbprint': type.OptionalType(type.StringType()),
        'name': type.StringType(),
    },
    HttpsProtocol,
    False,
    None))



class ICMPTypeNSService(VapiStruct):
    """
    A NSService that represents IPv4 or IPv6 ICMP protocol

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "ICMPTypeNSService"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    PROTOCOL_ICMPV4 = "ICMPv4"
    """


    """
    PROTOCOL_ICMPV6 = "ICMPv6"
    """


    """



    _canonical_to_pep_names = {
                            'icmp_code': 'icmp_code',
                            'icmp_type': 'icmp_type',
                            'protocol': 'protocol',
                            'resource_type': 'resource_type',
                            }

    def __init__(self,
                 icmp_code=None,
                 icmp_type=None,
                 protocol=None,
                 resource_type='ICMPTypeNSService',
                ):
        """
        :type  icmp_code: :class:`long` or ``None``
        :param icmp_code: ICMP message code format: int64
        :type  icmp_type: :class:`long` or ``None``
        :param icmp_type: ICMP message type format: int64
        :type  protocol: :class:`str` or ``None``
        :param protocol: Possible values are: 
            
            * :attr:`ICMPTypeNSService.PROTOCOL_ICMPV4`
            * :attr:`ICMPTypeNSService.PROTOCOL_ICMPV6`
            
             ICMP protocol type
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`NSServiceElement.RESOURCE_TYPE_ETHERTYPENSSERVICE`
            * :attr:`NSServiceElement.RESOURCE_TYPE_IPPROTOCOLNSSERVICE`
            * :attr:`NSServiceElement.RESOURCE_TYPE_IGMPTYPENSSERVICE`
            * :attr:`NSServiceElement.RESOURCE_TYPE_ICMPTYPENSSERVICE`
            * :attr:`NSServiceElement.RESOURCE_TYPE_ALGTYPENSSERVICE`
            * :attr:`NSServiceElement.RESOURCE_TYPE_L4PORTSETNSSERVICE`
            
             The specific type of NSServiceElement
        """
        self.icmp_code = icmp_code
        self.icmp_type = icmp_type
        self.protocol = protocol
        self._resource_type = resource_type
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

ICMPTypeNSService._set_binding_type(type.StructType(
    'com.vmware.nsx.model.ICMP_type_NS_service', {
        'icmp_code': type.OptionalType(type.IntegerType()),
        'icmp_type': type.OptionalType(type.IntegerType()),
        'protocol': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
    },
    ICMPTypeNSService,
    False,
    None))



class IDSEventDataRequest(VapiStruct):
    """
    Filtering parameters to get only a subset of intrusion events.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'filters': 'filters',
                            }

    def __init__(self,
                 filters=None,
                ):
        """
        :type  filters: :class:`list` of :class:`FilterRequest` or ``None``
        :param filters: An array of filter conditions.
        """
        self.filters = filters
        VapiStruct.__init__(self)


IDSEventDataRequest._set_binding_type(type.StructType(
    'com.vmware.nsx.model.IDS_event_data_request', {
        'filters': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'FilterRequest'))),
    },
    IDSEventDataRequest,
    False,
    None))



class IDSEventsBySignature(VapiStruct):
    """
    Intrusions that are detected, grouped by signature. It contains the
    signature id, severity, name, the number of intrusions of that type and the
    first occurence.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'count': 'count',
                            'first_occurence': 'first_occurence',
                            'is_ongoing': 'is_ongoing',
                            'resource_type': 'resource_type',
                            'severity': 'severity',
                            'signature_id': 'signature_id',
                            'signature_name': 'signature_name',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 count=None,
                 first_occurence=None,
                 is_ongoing=None,
                 resource_type=None,
                 severity=None,
                 signature_id=None,
                 signature_name=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  count: :class:`long` or ``None``
        :param count: Number of times this particular signature was detected. format:
            int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  first_occurence: :class:`long` or ``None``
        :param first_occurence: First occurence of the intrusion, in epoch milliseconds. format:
            int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  is_ongoing: :class:`bool` or ``None``
        :param is_ongoing: Flag indicating an ongoing intrusion.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: IDSEvent resource type.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  severity: :class:`str` or ``None``
        :param severity: Severity of the threat covered by the signature, can be Critical,
            High, Medium, or Low.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  signature_id: :class:`long` or ``None``
        :param signature_id: Signature ID pertaining to the detected intrusion. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  signature_name: :class:`str` or ``None``
        :param signature_name: Name of the signature pertaining to the detected intrusion.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.count = count
        self.first_occurence = first_occurence
        self.is_ongoing = is_ongoing
        self.resource_type = resource_type
        self.severity = severity
        self.signature_id = signature_id
        self.signature_name = signature_name
        VapiStruct.__init__(self)


IDSEventsBySignature._set_binding_type(type.StructType(
    'com.vmware.nsx.model.IDS_events_by_signature', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'count': type.OptionalType(type.IntegerType()),
        'first_occurence': type.OptionalType(type.IntegerType()),
        'is_ongoing': type.OptionalType(type.BooleanType()),
        'resource_type': type.OptionalType(type.StringType()),
        'severity': type.OptionalType(type.StringType()),
        'signature_id': type.OptionalType(type.IntegerType()),
        'signature_name': type.OptionalType(type.StringType()),
    },
    IDSEventsBySignature,
    False,
    None))



class IDSEventsBySignatureResult(VapiStruct):
    """
    List of all intrusions that are detected grouped by signature, it contains
    minimal details about the intrusions.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`IDSEventsBySignature` or ``None``
        :param results: List of all intrusions detected, grouped by signature. The details
            include signature id, name, severity, timestamp, and total number
            of attempts per signature.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


IDSEventsBySignatureResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.IDS_events_by_signature_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IDSEventsBySignature'))),
    },
    IDSEventsBySignatureResult,
    False,
    None))



class IDSEventsSummary(VapiStruct):
    """
    Intrusion event with all the event and signature details, each event
    contains the signature id, name, severity, first and recent occurence,
    users and VMs affected and other signature metadata.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'affected_vm_count': 'affected_vm_count',
                            'first_occurence': 'first_occurence',
                            'idsflow_details': 'idsflow_details',
                            'is_ongoing': 'is_ongoing',
                            'is_rule_valid': 'is_rule_valid',
                            'latest_occurence': 'latest_occurence',
                            'resource_type': 'resource_type',
                            'rule_id': 'rule_id',
                            'signature_id': 'signature_id',
                            'signature_metadata': 'signature_metadata',
                            'total_count': 'total_count',
                            'user_details': 'user_details',
                            'vm_details': 'vm_details',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 affected_vm_count=None,
                 first_occurence=None,
                 idsflow_details=None,
                 is_ongoing=None,
                 is_rule_valid=None,
                 latest_occurence=None,
                 resource_type=None,
                 rule_id=None,
                 signature_id=None,
                 signature_metadata=None,
                 total_count=None,
                 user_details=None,
                 vm_details=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  affected_vm_count: :class:`long` or ``None``
        :param affected_vm_count: Count of VMs on which a particular signature was detected. format:
            int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  first_occurence: :class:`long` or ``None``
        :param first_occurence: First occurence of the intrusion, in epoch milliseconds. format:
            int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  idsflow_details: :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param idsflow_details: IDS event flow data specific to each IDS event. The data includes
            source ip, source port, destination ip, destination port, and
            protocol.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  is_ongoing: :class:`bool` or ``None``
        :param is_ongoing: Flag indicating an ongoing intrusion.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  is_rule_valid: :class:`bool` or ``None``
        :param is_rule_valid: Indicates if the rule id is valid or not.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  latest_occurence: :class:`long` or ``None``
        :param latest_occurence: Latest occurence of the intrusion, in epoch milliseconds. format:
            int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: IDSEvent resource type.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  rule_id: :class:`long` or ``None``
        :param rule_id: The IDS Rule id that detected this particular intrusion. format:
            int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  signature_id: :class:`long` or ``None``
        :param signature_id: Signature ID pertaining to the detected intrusion. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  signature_metadata: :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param signature_metadata: Metadata about the detected signature including name, id, severity,
            product affected, protocol etc.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  total_count: :class:`long` or ``None``
        :param total_count: Number of times this particular signature was detected. format:
            int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  user_details: :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param user_details: List of users logged into VMs on which a particular signature was
            detected.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  vm_details: :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param vm_details: List of VMs on which a particular signature was detected with the
            count.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.affected_vm_count = affected_vm_count
        self.first_occurence = first_occurence
        self.idsflow_details = idsflow_details
        self.is_ongoing = is_ongoing
        self.is_rule_valid = is_rule_valid
        self.latest_occurence = latest_occurence
        self.resource_type = resource_type
        self.rule_id = rule_id
        self.signature_id = signature_id
        self.signature_metadata = signature_metadata
        self.total_count = total_count
        self.user_details = user_details
        self.vm_details = vm_details
        VapiStruct.__init__(self)


IDSEventsSummary._set_binding_type(type.StructType(
    'com.vmware.nsx.model.IDS_events_summary', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'affected_vm_count': type.OptionalType(type.IntegerType()),
        'first_occurence': type.OptionalType(type.IntegerType()),
        'idsflow_details': type.OptionalType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct)),
        'is_ongoing': type.OptionalType(type.BooleanType()),
        'is_rule_valid': type.OptionalType(type.BooleanType()),
        'latest_occurence': type.OptionalType(type.IntegerType()),
        'resource_type': type.OptionalType(type.StringType()),
        'rule_id': type.OptionalType(type.IntegerType()),
        'signature_id': type.OptionalType(type.IntegerType()),
        'signature_metadata': type.OptionalType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct)),
        'total_count': type.OptionalType(type.IntegerType()),
        'user_details': type.OptionalType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct)),
        'vm_details': type.OptionalType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct)),
    },
    IDSEventsSummary,
    False,
    None))



class IDSProfile(VapiStruct):
    """
    An entity that holds the list of IDS signatures which need to be detected.
    The profiles can be custom created or built in.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'signatures': 'signatures',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 signatures=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  signatures: :class:`list` of :class:`str` or ``None``
        :param signatures: List of IDS signatures ids which need to be detected.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.signatures = signatures
        VapiStruct.__init__(self)


IDSProfile._set_binding_type(type.StructType(
    'com.vmware.nsx.model.IDS_profile', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'signatures': type.OptionalType(type.ListType(type.StringType())),
    },
    IDSProfile,
    False,
    None))



class IDSSignatureDetail(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'action': 'action',
                            'affected_product': 'affected_product',
                            'attack_target': 'attack_target',
                            'category': 'category',
                            'class_type': 'class_type',
                            'cves': 'cves',
                            'cvssv2': 'cvssv2',
                            'cvssv3': 'cvssv3',
                            'direction': 'direction',
                            'enabled': 'enabled',
                            'flow': 'flow',
                            'malware_family': 'malware_family',
                            'name': 'name',
                            'performance_impact': 'performance_impact',
                            'policy': 'policy',
                            'protocol': 'protocol',
                            'resource_type': 'resource_type',
                            'severity': 'severity',
                            'signature_id': 'signature_id',
                            'signature_revision': 'signature_revision',
                            'signature_severity': 'signature_severity',
                            'tag': 'tag',
                            'type': 'type',
                            'urls': 'urls',
                            }

    def __init__(self,
                 action=None,
                 affected_product=None,
                 attack_target=None,
                 category=None,
                 class_type=None,
                 cves=None,
                 cvssv2=None,
                 cvssv3=None,
                 direction=None,
                 enabled=None,
                 flow=None,
                 malware_family=None,
                 name=None,
                 performance_impact=None,
                 policy=None,
                 protocol=None,
                 resource_type=None,
                 severity=None,
                 signature_id=None,
                 signature_revision=None,
                 signature_severity=None,
                 tag=None,
                 type=None,
                 urls=None,
                ):
        """
        :type  action: :class:`str` or ``None``
        :param action: Packet analysis action
        :type  affected_product: :class:`str` or ``None``
        :param affected_product: Product affected by the signature.
        :type  attack_target: :class:`str` or ``None``
        :param attack_target: Target of the attack tracked in the signature.
        :type  category: :class:`list` of :class:`str` or ``None``
        :param category: VMware defined signature category.
        :type  class_type: :class:`str` or ``None``
        :param class_type: Class type of the signature.
        :type  cves: :class:`list` of :class:`str` or ``None``
        :param cves: CVE of the signature.
        :type  cvssv2: :class:`str` or ``None``
        :param cvssv2: Signature CVSSV2 score.
        :type  cvssv3: :class:`str` or ``None``
        :param cvssv3: Signature CVSSV3 score.
        :type  direction: :class:`str` or ``None``
        :param direction: Source-destination direction.
        :type  enabled: :class:`bool` or ``None``
        :param enabled: Signature enabled.
        :type  flow: :class:`str` or ``None``
        :param flow: Flow established from server, from client etc.
        :type  malware_family: :class:`str` or ``None``
        :param malware_family: Family of the malware tracked in the signature.
        :type  name: :class:`str` or ``None``
        :param name: Name of the signature.
        :type  performance_impact: :class:`str` or ``None``
        :param performance_impact: Performance impact of the signature.
        :type  policy: :class:`list` of :class:`str` or ``None``
        :param policy: Signature policy.
        :type  protocol: :class:`str` or ``None``
        :param protocol: Protocol used in the packet analysis.
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: IDSSignatureDetail resource type.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  severity: :class:`str` or ``None``
        :param severity: VMware defined signature severity.
        :type  signature_id: :class:`long` or ``None``
        :param signature_id: Unique ID of the signature rule. format: int64
        :type  signature_revision: :class:`long` or ``None``
        :param signature_revision: The revision of the signature format: int64
        :type  signature_severity: :class:`str` or ``None``
        :param signature_severity: Signature vendor set severity of the signature rule.
        :type  tag: :class:`list` of :class:`str` or ``None``
        :param tag: Vendor assigned classification tag.
        :type  type: :class:`list` of :class:`str` or ``None``
        :param type: Signature type.
        :type  urls: :class:`list` of :class:`str` or ``None``
        :param urls: List of mitre attack URLs pertaining to signature.
        """
        self.action = action
        self.affected_product = affected_product
        self.attack_target = attack_target
        self.category = category
        self.class_type = class_type
        self.cves = cves
        self.cvssv2 = cvssv2
        self.cvssv3 = cvssv3
        self.direction = direction
        self.enabled = enabled
        self.flow = flow
        self.malware_family = malware_family
        self.name = name
        self.performance_impact = performance_impact
        self.policy = policy
        self.protocol = protocol
        self.resource_type = resource_type
        self.severity = severity
        self.signature_id = signature_id
        self.signature_revision = signature_revision
        self.signature_severity = signature_severity
        self.tag = tag
        self.type = type
        self.urls = urls
        VapiStruct.__init__(self)


IDSSignatureDetail._set_binding_type(type.StructType(
    'com.vmware.nsx.model.IDS_signature_detail', {
        'action': type.OptionalType(type.StringType()),
        'affected_product': type.OptionalType(type.StringType()),
        'attack_target': type.OptionalType(type.StringType()),
        'category': type.OptionalType(type.ListType(type.StringType())),
        'class_type': type.OptionalType(type.StringType()),
        'cves': type.OptionalType(type.ListType(type.StringType())),
        'cvssv2': type.OptionalType(type.StringType()),
        'cvssv3': type.OptionalType(type.StringType()),
        'direction': type.OptionalType(type.StringType()),
        'enabled': type.OptionalType(type.BooleanType()),
        'flow': type.OptionalType(type.StringType()),
        'malware_family': type.OptionalType(type.StringType()),
        'name': type.OptionalType(type.StringType()),
        'performance_impact': type.OptionalType(type.StringType()),
        'policy': type.OptionalType(type.ListType(type.StringType())),
        'protocol': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'severity': type.OptionalType(type.StringType()),
        'signature_id': type.OptionalType(type.IntegerType()),
        'signature_revision': type.OptionalType(type.IntegerType()),
        'signature_severity': type.OptionalType(type.StringType()),
        'tag': type.OptionalType(type.ListType(type.StringType())),
        'type': type.OptionalType(type.ListType(type.StringType())),
        'urls': type.OptionalType(type.ListType(type.StringType())),
    },
    IDSSignatureDetail,
    False,
    None))



class IDSSummaryListResult(VapiStruct):
    """
    List of all intrusions that are detected grouped by signature with their
    summary.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`IDSEventsSummary` or ``None``
        :param results: Paged collection of the detected intrusions.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


IDSSummaryListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.IDS_summary_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IDSEventsSummary'))),
    },
    IDSSummaryListResult,
    False,
    None))



class IGMPTypeNSService(VapiStruct):
    """
    A NSService that represents IGMP protocol

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "IGMPTypeNSService"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'resource_type': 'resource_type',
                            }

    def __init__(self,
                 resource_type='IGMPTypeNSService',
                ):
        """
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`NSServiceElement.RESOURCE_TYPE_ETHERTYPENSSERVICE`
            * :attr:`NSServiceElement.RESOURCE_TYPE_IPPROTOCOLNSSERVICE`
            * :attr:`NSServiceElement.RESOURCE_TYPE_IGMPTYPENSSERVICE`
            * :attr:`NSServiceElement.RESOURCE_TYPE_ICMPTYPENSSERVICE`
            * :attr:`NSServiceElement.RESOURCE_TYPE_ALGTYPENSSERVICE`
            * :attr:`NSServiceElement.RESOURCE_TYPE_L4PORTSETNSSERVICE`
            
             The specific type of NSServiceElement
        """
        self._resource_type = resource_type
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

IGMPTypeNSService._set_binding_type(type.StructType(
    'com.vmware.nsx.model.IGMP_type_NS_service', {
        'resource_type': type.StringType(),
    },
    IGMPTypeNSService,
    False,
    None))



class IPAddressElement(VapiStruct):
    """
    IP Address

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            'ip_address': 'ip_address',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 ip_address=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  ip_address: :class:`str` or ``None``
        :param ip_address: IPElement can be a single IP address, IP address range or a Subnet.
            Its type can be of IPv4 or IPv6. Supported list of formats are
            \"192.168.1.1\", \"192.168.1.1-192.168.1.100\", \"192.168.0.0/24\",
            \"fe80::250:56ff:fe83:318c\",
            \"fe80::250:56ff:fe83:3181-fe80::250:56ff:fe83:318c\",
            \"fe80::250:56ff:fe83:318c/64\" format: address-or-block-or-range
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.ip_address = ip_address
        VapiStruct.__init__(self)


IPAddressElement._set_binding_type(type.StructType(
    'com.vmware.nsx.model.IP_address_element', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        'ip_address': type.OptionalType(type.StringType()),
    },
    IPAddressElement,
    False,
    None))



class IPAddressElementListResult(VapiStruct):
    """
    Collection of IP address elements

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`IPAddressElement` or ``None``
        :param results: IP address element list
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


IPAddressElementListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.IP_address_element_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IPAddressElement'))),
    },
    IPAddressElementListResult,
    False,
    None))



class IPAddresses(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'ip_addresses': 'ip_addresses',
                            }

    def __init__(self,
                 ip_addresses=None,
                ):
        """
        :type  ip_addresses: :class:`list` of :class:`str` or ``None``
        :param ip_addresses: The IP addresses in the form of IP Address, IP Range, CIDR, used as
            source IPs or destination IPs of filters. format:
            address-or-block-or-range
        """
        self.ip_addresses = ip_addresses
        VapiStruct.__init__(self)


IPAddresses._set_binding_type(type.StructType(
    'com.vmware.nsx.model.IP_addresses', {
        'ip_addresses': type.OptionalType(type.ListType(type.StringType())),
    },
    IPAddresses,
    False,
    None))



class IPInfo(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'ip_addresses': 'ip_addresses',
                            'prefix_length': 'prefix_length',
                            }

    def __init__(self,
                 ip_addresses=None,
                 prefix_length=None,
                ):
        """
        :type  ip_addresses: :class:`list` of :class:`str` or ``None``
        :param ip_addresses: IPv4 Addresses format: ipv4
        :type  prefix_length: :class:`long` or ``None``
        :param prefix_length: Subnet Prefix Length format: int64
        """
        self.ip_addresses = ip_addresses
        self.prefix_length = prefix_length
        VapiStruct.__init__(self)


IPInfo._set_binding_type(type.StructType(
    'com.vmware.nsx.model.IP_info', {
        'ip_addresses': type.OptionalType(type.ListType(type.StringType())),
        'prefix_length': type.OptionalType(type.IntegerType()),
    },
    IPInfo,
    False,
    None))



class IPMirrorDestination(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "IPMirrorDestination"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    ENCAPSULATION_TYPE_GRE = "GRE"
    """


    """
    ENCAPSULATION_TYPE_ERSPAN_TWO = "ERSPAN_TWO"
    """


    """
    ENCAPSULATION_TYPE_ERSPAN_THREE = "ERSPAN_THREE"
    """


    """



    _canonical_to_pep_names = {
                            'destination_ips': 'destination_ips',
                            'encapsulation_type': 'encapsulation_type',
                            'erspan_id': 'erspan_id',
                            'gre_key': 'gre_key',
                            'resource_type': 'resource_type',
                            }

    def __init__(self,
                 destination_ips=None,
                 encapsulation_type=None,
                 erspan_id=None,
                 gre_key=None,
                 resource_type='IPMirrorDestination',
                ):
        """
        :type  destination_ips: :class:`list` of :class:`str` or ``None``
        :param destination_ips: The destination IPs of the mirror packet will be sent to. format:
            ip
        :type  encapsulation_type: :class:`str` or ``None``
        :param encapsulation_type: Possible values are: 
            
            * :attr:`IPMirrorDestination.ENCAPSULATION_TYPE_GRE`
            * :attr:`IPMirrorDestination.ENCAPSULATION_TYPE_ERSPAN_TWO`
            * :attr:`IPMirrorDestination.ENCAPSULATION_TYPE_ERSPAN_THREE`
            
             You can choose GRE, ERSPAN II or ERSPAN III.
        :type  erspan_id: :class:`long` or ``None``
        :param erspan_id: Used by physical switch for the mirror traffic forwarding. Must be
            provided and only effective when encapsulation type is ERSPAN type
            II or type III. format: int32
        :type  gre_key: :class:`long` or ``None``
        :param gre_key: User-configurable 32-bit key only for GRE format: int32
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            *
              :attr:`MirrorDestination.RESOURCE_TYPE_LOGICALPORTMIRRORDESTINATION`
            * :attr:`MirrorDestination.RESOURCE_TYPE_PNICMIRRORDESTINATION`
            * :attr:`MirrorDestination.RESOURCE_TYPE_IPMIRRORDESTINATION`
            
             Resource types of mirror destination
        """
        self.destination_ips = destination_ips
        self.encapsulation_type = encapsulation_type
        self.erspan_id = erspan_id
        self.gre_key = gre_key
        self._resource_type = resource_type
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

IPMirrorDestination._set_binding_type(type.StructType(
    'com.vmware.nsx.model.IP_mirror_destination', {
        'destination_ips': type.OptionalType(type.ListType(type.StringType())),
        'encapsulation_type': type.OptionalType(type.StringType()),
        'erspan_id': type.OptionalType(type.IntegerType()),
        'gre_key': type.OptionalType(type.IntegerType()),
        'resource_type': type.StringType(),
    },
    IPMirrorDestination,
    False,
    None))



class IPPrefixList(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'logical_router_id': 'logical_router_id',
                            'prefixes': 'prefixes',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 logical_router_id=None,
                 prefixes=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  logical_router_id: :class:`str` or ``None``
        :param logical_router_id: Logical router id
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  prefixes: :class:`list` of :class:`PrefixConfig` or ``None``
        :param prefixes: Ordered list of PrefixConfig
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.logical_router_id = logical_router_id
        self.prefixes = prefixes
        VapiStruct.__init__(self)


IPPrefixList._set_binding_type(type.StructType(
    'com.vmware.nsx.model.IP_prefix_list', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'logical_router_id': type.OptionalType(type.StringType()),
        'prefixes': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'PrefixConfig'))),
    },
    IPPrefixList,
    False,
    None))



class IPPrefixListListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`IPPrefixList` or ``None``
        :param results: Paginated list of IPPrefixLists
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


IPPrefixListListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.IP_prefix_list_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IPPrefixList'))),
    },
    IPPrefixListListResult,
    False,
    None))



class IPProtocolNSService(VapiStruct):
    """
    An NSService element that represents an IP protocol

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "IPProtocolNSService"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'protocol_number': 'protocol_number',
                            'resource_type': 'resource_type',
                            }

    def __init__(self,
                 protocol_number=None,
                 resource_type='IPProtocolNSService',
                ):
        """
        :type  protocol_number: :class:`long` or ``None``
        :param protocol_number: The IP protocol number format: int64
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`NSServiceElement.RESOURCE_TYPE_ETHERTYPENSSERVICE`
            * :attr:`NSServiceElement.RESOURCE_TYPE_IPPROTOCOLNSSERVICE`
            * :attr:`NSServiceElement.RESOURCE_TYPE_IGMPTYPENSSERVICE`
            * :attr:`NSServiceElement.RESOURCE_TYPE_ICMPTYPENSSERVICE`
            * :attr:`NSServiceElement.RESOURCE_TYPE_ALGTYPENSSERVICE`
            * :attr:`NSServiceElement.RESOURCE_TYPE_L4PORTSETNSSERVICE`
            
             The specific type of NSServiceElement
        """
        self.protocol_number = protocol_number
        self._resource_type = resource_type
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

IPProtocolNSService._set_binding_type(type.StructType(
    'com.vmware.nsx.model.IP_protocol_NS_service', {
        'protocol_number': type.OptionalType(type.IntegerType()),
        'resource_type': type.StringType(),
    },
    IPProtocolNSService,
    False,
    None))



class IPSecVPNDPDProfile(VapiStruct):
    """
    Dead peer detection (DPD) is a method that allows detection of unreachable
    internet key excahnge (IKE) peers. Any changes affects all IPSec VPN
    sessions consuming this profile.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    DPD_PROBE_MODE_PERIODIC = "PERIODIC"
    """


    """
    DPD_PROBE_MODE_ON_DEMAND = "ON_DEMAND"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'dpd_probe_interval': 'dpd_probe_interval',
                            'dpd_probe_mode': 'dpd_probe_mode',
                            'enabled': 'enabled',
                            'retry_count': 'retry_count',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 dpd_probe_interval=None,
                 dpd_probe_mode=None,
                 enabled=None,
                 retry_count=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  dpd_probe_interval: :class:`long` or ``None``
        :param dpd_probe_interval: When the DPD probe mode is periodic, this interval is the number of
            seconds between DPD messages. When the DPD probe mode is on-demand,
            this interval is the number of seconds during which traffic is not
            received from the peer before DPD retry messages are sent if there
            is IPSec traffic to send. For PERIODIC Mode: Minimum: 3 Maximum:
            360 Default: 60 For ON_DEMAND Mode: Minimum: 1 Maximum: 10 Default:
            3 format: int64
        :type  dpd_probe_mode: :class:`str` or ``None``
        :param dpd_probe_mode: Possible values are: 
            
            * :attr:`IPSecVPNDPDProfile.DPD_PROBE_MODE_PERIODIC`
            * :attr:`IPSecVPNDPDProfile.DPD_PROBE_MODE_ON_DEMAND`
            
            DPD probe mode is used to query the liveliness of the peer. Two
            modes are possible - PERIODIC - is used to query the liveliness of
            the peer at regular intervals (dpd_probe_interval). It does not
            take into consideration traffic coming from the peer. The benefit
            of this mode over the on-demand mode is earlier detection of dead
            peers. However, use of periodic DPD incurs extra overhead. When
            communicating to large numbers of peers, please consider using
            on-demand DPD instead. ON_DEMAND - is used to query the liveliness
            of the peer by instructing the local endpoint to send DPD message
            to a peer if there is traffic to send to the peer AND the peer was
            idle for dpd_probe_interval seconds (i.e. there was no traffic from
            the peer for dpd_probe_interval seconds)
        :type  enabled: :class:`bool` or ``None``
        :param enabled: If true, enable dead peer detection.
        :type  retry_count: :class:`long` or ``None``
        :param retry_count: Maximum number of DPD messages retry attempts. This value is
            applicable for both dpd probe modes, periodic and on-demand.
            format: int64
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.dpd_probe_interval = dpd_probe_interval
        self.dpd_probe_mode = dpd_probe_mode
        self.enabled = enabled
        self.retry_count = retry_count
        VapiStruct.__init__(self)


IPSecVPNDPDProfile._set_binding_type(type.StructType(
    'com.vmware.nsx.model.IP_sec_VPNDPD_profile', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'dpd_probe_interval': type.OptionalType(type.IntegerType()),
        'dpd_probe_mode': type.OptionalType(type.StringType()),
        'enabled': type.OptionalType(type.BooleanType()),
        'retry_count': type.OptionalType(type.IntegerType()),
    },
    IPSecVPNDPDProfile,
    False,
    None))



class IPSecVPNDPDProfileListResult(VapiStruct):
    """
    List all the dead peer detection (DPD) profiles.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`IPSecVPNDPDProfile` or ``None``
        :param results: IPSec DPD Profile list results
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


IPSecVPNDPDProfileListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.IP_sec_VPNDPD_profile_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IPSecVPNDPDProfile'))),
    },
    IPSecVPNDPDProfileListResult,
    False,
    None))



class IPSecVPNIKEProfile(VapiStruct):
    """
    IKE Profile is a reusable profile that captures IKE phase one negotiation
    parameters. Any changes affects all IPSec VPN sessions consuming this
    profile.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    DH_GROUPS_GROUP2 = "GROUP2"
    """


    """
    DH_GROUPS_GROUP5 = "GROUP5"
    """


    """
    DH_GROUPS_GROUP14 = "GROUP14"
    """


    """
    DH_GROUPS_GROUP15 = "GROUP15"
    """


    """
    DH_GROUPS_GROUP16 = "GROUP16"
    """


    """
    DH_GROUPS_GROUP19 = "GROUP19"
    """


    """
    DH_GROUPS_GROUP20 = "GROUP20"
    """


    """
    DH_GROUPS_GROUP21 = "GROUP21"
    """


    """
    DIGEST_ALGORITHMS_SHA1 = "SHA1"
    """


    """
    DIGEST_ALGORITHMS_SHA2_256 = "SHA2_256"
    """


    """
    DIGEST_ALGORITHMS_SHA2_384 = "SHA2_384"
    """


    """
    DIGEST_ALGORITHMS_SHA2_512 = "SHA2_512"
    """


    """
    ENCRYPTION_ALGORITHMS_128 = "AES_128"
    """


    """
    ENCRYPTION_ALGORITHMS_256 = "AES_256"
    """


    """
    ENCRYPTION_ALGORITHMS_GCM_128 = "AES_GCM_128"
    """


    """
    ENCRYPTION_ALGORITHMS_GCM_192 = "AES_GCM_192"
    """


    """
    ENCRYPTION_ALGORITHMS_GCM_256 = "AES_GCM_256"
    """


    """
    IKE_VERSION_V1 = "IKE_V1"
    """


    """
    IKE_VERSION_V2 = "IKE_V2"
    """


    """
    IKE_VERSION_FLEX = "IKE_FLEX"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'dh_groups': 'dh_groups',
                            'digest_algorithms': 'digest_algorithms',
                            'encryption_algorithms': 'encryption_algorithms',
                            'ike_version': 'ike_version',
                            'sa_life_time': 'sa_life_time',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 dh_groups=None,
                 digest_algorithms=None,
                 encryption_algorithms=None,
                 ike_version=None,
                 sa_life_time=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  dh_groups: :class:`list` of :class:`str` or ``None``
        :param dh_groups: Possible values are: 
            
            * :attr:`IPSecVPNIKEProfile.DH_GROUPS_GROUP2`
            * :attr:`IPSecVPNIKEProfile.DH_GROUPS_GROUP5`
            * :attr:`IPSecVPNIKEProfile.DH_GROUPS_GROUP14`
            * :attr:`IPSecVPNIKEProfile.DH_GROUPS_GROUP15`
            * :attr:`IPSecVPNIKEProfile.DH_GROUPS_GROUP16`
            * :attr:`IPSecVPNIKEProfile.DH_GROUPS_GROUP19`
            * :attr:`IPSecVPNIKEProfile.DH_GROUPS_GROUP20`
            * :attr:`IPSecVPNIKEProfile.DH_GROUPS_GROUP21`
            
            Diffie-Hellman group to be used if PFS is enabled. Default is
            GROUP14.
        :type  digest_algorithms: :class:`list` of :class:`str` or ``None``
        :param digest_algorithms: Possible values are: 
            
            * :attr:`IPSecVPNIKEProfile.DIGEST_ALGORITHMS_SHA1`
            * :attr:`IPSecVPNIKEProfile.DIGEST_ALGORITHMS_SHA2_256`
            * :attr:`IPSecVPNIKEProfile.DIGEST_ALGORITHMS_SHA2_384`
            * :attr:`IPSecVPNIKEProfile.DIGEST_ALGORITHMS_SHA2_512`
            
            Algorithm to be used for message digest during Internet Key
            Exchange(IKE) negotiation. Default is SHA2_256.
        :type  encryption_algorithms: :class:`list` of :class:`str` or ``None``
        :param encryption_algorithms: Possible values are: 
            
            * :attr:`IPSecVPNIKEProfile.ENCRYPTION_ALGORITHMS__128`
            * :attr:`IPSecVPNIKEProfile.ENCRYPTION_ALGORITHMS__256`
            * :attr:`IPSecVPNIKEProfile.ENCRYPTION_ALGORITHMS_GCM_128`
            * :attr:`IPSecVPNIKEProfile.ENCRYPTION_ALGORITHMS_GCM_192`
            * :attr:`IPSecVPNIKEProfile.ENCRYPTION_ALGORITHMS_GCM_256`
            
            Encryption algorithm is used during Internet Key Exchange(IKE)
            negotiation. Default is AES_128.
        :type  ike_version: :class:`str` or ``None``
        :param ike_version: Possible values are: 
            
            * :attr:`IPSecVPNIKEProfile.IKE_VERSION_V1`
            * :attr:`IPSecVPNIKEProfile.IKE_VERSION_V2`
            * :attr:`IPSecVPNIKEProfile.IKE_VERSION_FLEX`
            
            IKE protocol version to be used. IKE-Flex will initiate IKE-V2 and
            responds to both IKE-V1 and IKE-V2.
        :type  sa_life_time: :class:`long` or ``None``
        :param sa_life_time: Life time for security association. Default is 86400 seconds (1
            day). format: int64
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.dh_groups = dh_groups
        self.digest_algorithms = digest_algorithms
        self.encryption_algorithms = encryption_algorithms
        self.ike_version = ike_version
        self.sa_life_time = sa_life_time
        VapiStruct.__init__(self)


IPSecVPNIKEProfile._set_binding_type(type.StructType(
    'com.vmware.nsx.model.IP_sec_VPNIKE_profile', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'dh_groups': type.OptionalType(type.ListType(type.StringType())),
        'digest_algorithms': type.OptionalType(type.ListType(type.StringType())),
        'encryption_algorithms': type.OptionalType(type.ListType(type.StringType())),
        'ike_version': type.OptionalType(type.StringType()),
        'sa_life_time': type.OptionalType(type.IntegerType()),
    },
    IPSecVPNIKEProfile,
    False,
    None))



class IPSecVPNIKEProfileListResult(VapiStruct):
    """
    List all the IKE profiles.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`IPSecVPNIKEProfile` or ``None``
        :param results: IKE Profile list results
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


IPSecVPNIKEProfileListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.IP_sec_VPNIKE_profile_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IPSecVPNIKEProfile'))),
    },
    IPSecVPNIKEProfileListResult,
    False,
    None))



class IPSecVPNIKEServiceSummary(VapiStruct):
    """
    Summarized view of all IPSec VPN sessions for a specified service.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'aggregate_traffic_counters': 'aggregate_traffic_counters',
                            'last_update_timestamp': 'last_update_timestamp',
                            'session_summary': 'session_summary',
                            'traffic_summary_per_session': 'traffic_summary_per_session',
                            'display_name': 'display_name',
                            'ipsec_vpn_service_id': 'ipsec_vpn_service_id',
                            'logical_router_id': 'logical_router_id',
                            }

    def __init__(self,
                 aggregate_traffic_counters=None,
                 last_update_timestamp=None,
                 session_summary=None,
                 traffic_summary_per_session=None,
                 display_name=None,
                 ipsec_vpn_service_id=None,
                 logical_router_id=None,
                ):
        """
        :type  aggregate_traffic_counters: :class:`IPSecVPNTrafficCounters` or ``None``
        :param aggregate_traffic_counters: Aggregate traffic statistics across all selected sessions.
        :type  last_update_timestamp: :class:`long` or ``None``
        :param last_update_timestamp: Timestamp when the data was last updated. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  session_summary: :class:`IPsecVPNIKESessionSummary` or ``None``
        :param session_summary: Session summary for number of total, established, failed and
            degraded IPSec VPN sessions.
        :type  traffic_summary_per_session: :class:`list` of :class:`IPSecVPNSessionTrafficSummary` or ``None``
        :param traffic_summary_per_session: Traffic summary per session.
        :type  display_name: :class:`str` or ``None``
        :param display_name: VPN service display name.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  ipsec_vpn_service_id: :class:`str` or ``None``
        :param ipsec_vpn_service_id: UUID for a vpn service.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  logical_router_id: :class:`str` or ``None``
        :param logical_router_id: Logical router identifier associated with vpn service.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.aggregate_traffic_counters = aggregate_traffic_counters
        self.last_update_timestamp = last_update_timestamp
        self.session_summary = session_summary
        self.traffic_summary_per_session = traffic_summary_per_session
        self.display_name = display_name
        self.ipsec_vpn_service_id = ipsec_vpn_service_id
        self.logical_router_id = logical_router_id
        VapiStruct.__init__(self)


IPSecVPNIKEServiceSummary._set_binding_type(type.StructType(
    'com.vmware.nsx.model.IP_sec_VPNIKE_service_summary', {
        'aggregate_traffic_counters': type.OptionalType(type.ReferenceType(__name__, 'IPSecVPNTrafficCounters')),
        'last_update_timestamp': type.OptionalType(type.IntegerType()),
        'session_summary': type.OptionalType(type.ReferenceType(__name__, 'IPsecVPNIKESessionSummary')),
        'traffic_summary_per_session': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IPSecVPNSessionTrafficSummary'))),
        'display_name': type.OptionalType(type.StringType()),
        'ipsec_vpn_service_id': type.OptionalType(type.StringType()),
        'logical_router_id': type.OptionalType(type.StringType()),
    },
    IPSecVPNIKEServiceSummary,
    False,
    None))



class IPSecVPNIKESessionStatus(VapiStruct):
    """
    Status for IPSec VPN IKE session UP, DOWN, NEGOTIATING and fail reason if
    IKE session is down.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    IKE_SESSION_STATE_UP = "UP"
    """


    """
    IKE_SESSION_STATE_DOWN = "DOWN"
    """


    """
    IKE_SESSION_STATE_NEGOTIATING = "NEGOTIATING"
    """


    """



    _canonical_to_pep_names = {
                            'fail_reason': 'fail_reason',
                            'ike_session_state': 'ike_session_state',
                            'transport_node_id': 'transport_node_id',
                            }

    def __init__(self,
                 fail_reason=None,
                 ike_session_state=None,
                 transport_node_id=None,
                ):
        """
        :type  fail_reason: :class:`str` or ``None``
        :param fail_reason: Reason for failure.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  ike_session_state: :class:`str` or ``None``
        :param ike_session_state: Possible values are: 
            
            * :attr:`IPSecVPNIKESessionStatus.IKE_SESSION_STATE_UP`
            * :attr:`IPSecVPNIKESessionStatus.IKE_SESSION_STATE_DOWN`
            * :attr:`IPSecVPNIKESessionStatus.IKE_SESSION_STATE_NEGOTIATING`
            
             IKE session service status UP, DOWN and NEGOTIATING.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  transport_node_id: :class:`str` or ``None``
        :param transport_node_id: Transport Node identifier where session is present.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.fail_reason = fail_reason
        self.ike_session_state = ike_session_state
        self.transport_node_id = transport_node_id
        VapiStruct.__init__(self)


IPSecVPNIKESessionStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.IP_sec_VPNIKE_session_status', {
        'fail_reason': type.OptionalType(type.StringType()),
        'ike_session_state': type.OptionalType(type.StringType()),
        'transport_node_id': type.OptionalType(type.StringType()),
    },
    IPSecVPNIKESessionStatus,
    False,
    None))



class IPSecVPNIKETrafficStatistics(VapiStruct):
    """
    Traffic statistics for IPSec VPN IKE session. Note - Not supported in this
    release.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'bytes_in': 'bytes_in',
                            'bytes_out': 'bytes_out',
                            'fail_count': 'fail_count',
                            'packets_in': 'packets_in',
                            'packets_out': 'packets_out',
                            }

    def __init__(self,
                 bytes_in=None,
                 bytes_out=None,
                 fail_count=None,
                 packets_in=None,
                 packets_out=None,
                ):
        """
        :type  bytes_in: :class:`long` or ``None``
        :param bytes_in: Number of bytes in. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  bytes_out: :class:`long` or ``None``
        :param bytes_out: Number of bytes out. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  fail_count: :class:`long` or ``None``
        :param fail_count: Fail count. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  packets_in: :class:`long` or ``None``
        :param packets_in: Number of packets in. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  packets_out: :class:`long` or ``None``
        :param packets_out: Number of packets out. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.bytes_in = bytes_in
        self.bytes_out = bytes_out
        self.fail_count = fail_count
        self.packets_in = packets_in
        self.packets_out = packets_out
        VapiStruct.__init__(self)


IPSecVPNIKETrafficStatistics._set_binding_type(type.StructType(
    'com.vmware.nsx.model.IP_sec_VPNIKE_traffic_statistics', {
        'bytes_in': type.OptionalType(type.IntegerType()),
        'bytes_out': type.OptionalType(type.IntegerType()),
        'fail_count': type.OptionalType(type.IntegerType()),
        'packets_in': type.OptionalType(type.IntegerType()),
        'packets_out': type.OptionalType(type.IntegerType()),
    },
    IPSecVPNIKETrafficStatistics,
    False,
    None))



class IPSecVPNLocalEndpoint(VapiStruct):
    """
    Local endpoint represents a logical router on which tunnel needs to be
    terminated.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'certificate_id': 'certificate_id',
                            'ipsec_vpn_service_id': 'ipsec_vpn_service_id',
                            'local_address': 'local_address',
                            'local_id': 'local_id',
                            'trust_ca_ids': 'trust_ca_ids',
                            'trust_crl_ids': 'trust_crl_ids',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 certificate_id=None,
                 ipsec_vpn_service_id=None,
                 local_address=None,
                 local_id=None,
                 trust_ca_ids=None,
                 trust_crl_ids=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  certificate_id: :class:`str` or ``None``
        :param certificate_id: Site certificate identifier.
        :type  ipsec_vpn_service_id: :class:`ResourceReference` or ``None``
        :param ipsec_vpn_service_id: VPN Service id.
        :type  local_address: :class:`str` or ``None``
        :param local_address: IPV4 Address for local endpoint. format: ipv4
        :type  local_id: :class:`str` or ``None``
        :param local_id: Local identifier.
        :type  trust_ca_ids: :class:`list` of :class:`str` or ``None``
        :param trust_ca_ids: Certificate authority (CA) identifier list to verify peer
            certificates.
        :type  trust_crl_ids: :class:`list` of :class:`str` or ``None``
        :param trust_crl_ids: Certificate revocation list (CRL) identifier list of peer
            certificates.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.certificate_id = certificate_id
        self.ipsec_vpn_service_id = ipsec_vpn_service_id
        self.local_address = local_address
        self.local_id = local_id
        self.trust_ca_ids = trust_ca_ids
        self.trust_crl_ids = trust_crl_ids
        VapiStruct.__init__(self)


IPSecVPNLocalEndpoint._set_binding_type(type.StructType(
    'com.vmware.nsx.model.IP_sec_VPN_local_endpoint', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'certificate_id': type.OptionalType(type.StringType()),
        'ipsec_vpn_service_id': type.OptionalType(type.ReferenceType(__name__, 'ResourceReference')),
        'local_address': type.OptionalType(type.StringType()),
        'local_id': type.OptionalType(type.StringType()),
        'trust_ca_ids': type.OptionalType(type.ListType(type.StringType())),
        'trust_crl_ids': type.OptionalType(type.ListType(type.StringType())),
    },
    IPSecVPNLocalEndpoint,
    False,
    None))



class IPSecVPNLocalEndpointListResult(VapiStruct):
    """
    List all the local endpoints.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`IPSecVPNLocalEndpoint` or ``None``
        :param results: IPSec local endpoint list results
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


IPSecVPNLocalEndpointListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.IP_sec_VPN_local_endpoint_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IPSecVPNLocalEndpoint'))),
    },
    IPSecVPNLocalEndpointListResult,
    False,
    None))



class IPSecVPNPeerEndpoint(VapiStruct):
    """
    IPSec VPN Peer Endpoint covers configuration to be applied locally to
    establish a session with remote endpoint on peer site.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    AUTHENTICATION_MODE_PSK = "PSK"
    """


    """
    AUTHENTICATION_MODE_CERTIFICATE = "CERTIFICATE"
    """


    """
    CONNECTION_INITIATION_MODE_INITIATOR = "INITIATOR"
    """


    """
    CONNECTION_INITIATION_MODE_RESPOND_ONLY = "RESPOND_ONLY"
    """


    """
    CONNECTION_INITIATION_MODE_ON_DEMAND = "ON_DEMAND"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'authentication_mode': 'authentication_mode',
                            'connection_initiation_mode': 'connection_initiation_mode',
                            'dpd_profile_id': 'dpd_profile_id',
                            'ike_profile_id': 'ike_profile_id',
                            'ipsec_tunnel_profile_id': 'ipsec_tunnel_profile_id',
                            'peer_address': 'peer_address',
                            'peer_id': 'peer_id',
                            'psk': 'psk',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 authentication_mode=None,
                 connection_initiation_mode=None,
                 dpd_profile_id=None,
                 ike_profile_id=None,
                 ipsec_tunnel_profile_id=None,
                 peer_address=None,
                 peer_id=None,
                 psk=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  authentication_mode: :class:`str` or ``None``
        :param authentication_mode: Possible values are: 
            
            * :attr:`IPSecVPNPeerEndpoint.AUTHENTICATION_MODE_PSK`
            * :attr:`IPSecVPNPeerEndpoint.AUTHENTICATION_MODE_CERTIFICATE`
            
            Authentication mode used for the peer authentication. For PSK (Pre
            Shared Key) authentication mode, 'psk' property is mandatory and
            for the CERTIFICATE authentication mode, 'peer_id' property is
            mandatory.
        :type  connection_initiation_mode: :class:`str` or ``None``
        :param connection_initiation_mode: Possible values are: 
            
            * :attr:`IPSecVPNPeerEndpoint.CONNECTION_INITIATION_MODE_INITIATOR`
            *
              :attr:`IPSecVPNPeerEndpoint.CONNECTION_INITIATION_MODE_RESPOND_ONLY`
            * :attr:`IPSecVPNPeerEndpoint.CONNECTION_INITIATION_MODE_ON_DEMAND`
            
            Connection initiation mode used by local endpoint to establish ike
            connection with peer endpoint. INITIATOR - In this mode local
            endpoint initiates tunnel setup and will also respond to incoming
            tunnel setup requests from peer gateway. RESPOND_ONLY - In this
            mode, local endpoint shall only respond to incoming tunnel setup
            requests. It shall not initiate the tunnel setup. ON_DEMAND - In
            this mode local endpoint will initiate tunnel creation once first
            packet matching the policy rule is received and will also respond
            to incoming initiation request.
        :type  dpd_profile_id: :class:`str` or ``None``
        :param dpd_profile_id: Dead peer detection (DPD) profile id. Default will be set according
            to system default policy.
        :type  ike_profile_id: :class:`str` or ``None``
        :param ike_profile_id: IKE profile id to be used. Default will be set according to system
            default policy.
        :type  ipsec_tunnel_profile_id: :class:`str` or ``None``
        :param ipsec_tunnel_profile_id: Tunnel profile id to be used. By default it will point to system
            default profile.
        :type  peer_address: :class:`str` or ``None``
        :param peer_address: IPV4 address of peer endpoint on remote site.
        :type  peer_id: :class:`str` or ``None``
        :param peer_id: Peer identifier.
        :type  psk: :class:`str` or ``None``
        :param psk: IPSec Pre-shared key. Maximum length of this field is 128
            characters.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.authentication_mode = authentication_mode
        self.connection_initiation_mode = connection_initiation_mode
        self.dpd_profile_id = dpd_profile_id
        self.ike_profile_id = ike_profile_id
        self.ipsec_tunnel_profile_id = ipsec_tunnel_profile_id
        self.peer_address = peer_address
        self.peer_id = peer_id
        self.psk = psk
        VapiStruct.__init__(self)


IPSecVPNPeerEndpoint._set_binding_type(type.StructType(
    'com.vmware.nsx.model.IP_sec_VPN_peer_endpoint', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'authentication_mode': type.OptionalType(type.StringType()),
        'connection_initiation_mode': type.OptionalType(type.StringType()),
        'dpd_profile_id': type.OptionalType(type.StringType()),
        'ike_profile_id': type.OptionalType(type.StringType()),
        'ipsec_tunnel_profile_id': type.OptionalType(type.StringType()),
        'peer_address': type.OptionalType(type.StringType()),
        'peer_id': type.OptionalType(type.StringType()),
        'psk': type.OptionalType(type.StringType()),
    },
    IPSecVPNPeerEndpoint,
    False,
    None))



class IPSecVPNPeerEndpointListResult(VapiStruct):
    """
    List all the peer endpoints.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`IPSecVPNPeerEndpoint` or ``None``
        :param results: IPSec Peer endpoint list results
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


IPSecVPNPeerEndpointListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.IP_sec_VPN_peer_endpoint_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IPSecVPNPeerEndpoint'))),
    },
    IPSecVPNPeerEndpointListResult,
    False,
    None))



class IPSecVPNPolicyRule(VapiStruct):
    """
    For policy-based IPsec VPNs, a security policy specifies as its action the
    VPN tunnel to be used for transit traffic that meets the policy's match
    criteria.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    ACTION_PROTECT = "PROTECT"
    """


    """
    ACTION_BYPASS = "BYPASS"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_owner': 'owner',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'action': 'action',
                            'destinations': 'destinations',
                            'enabled': 'enabled',
                            'logged': 'logged',
                            'sources': 'sources',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 owner=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 action=None,
                 destinations=None,
                 enabled=None,
                 logged=None,
                 sources=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  owner: :class:`OwnerResourceLink` or ``None``
        :param owner: Owner of this resource
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique policy id.
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  action: :class:`str` or ``None``
        :param action: Possible values are: 
            
            * :attr:`IPSecVPNPolicyRule.ACTION_PROTECT`
            * :attr:`IPSecVPNPolicyRule.ACTION_BYPASS`
            
            PROTECT - Protect rules are defined per policy based IPSec VPN
            session. BYPASS - Bypass rules are defined per IPSec VPN service
            and affects all policy based IPSec VPN sessions. Bypass rules are
            prioritized over protect rules.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  destinations: :class:`list` of :class:`IPSecVPNPolicySubnet` or ``None``
        :param destinations: List of peer subnets.
        :type  enabled: :class:`bool` or ``None``
        :param enabled: A flag to enable/disable the policy rule.
        :type  logged: :class:`bool` or ``None``
        :param logged: A flag to enable/disable the logging for the policy rule.
        :type  sources: :class:`list` of :class:`IPSecVPNPolicySubnet` or ``None``
        :param sources: List of local subnets.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.owner = owner
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.action = action
        self.destinations = destinations
        self.enabled = enabled
        self.logged = logged
        self.sources = sources
        VapiStruct.__init__(self)


IPSecVPNPolicyRule._set_binding_type(type.StructType(
    'com.vmware.nsx.model.IP_sec_VPN_policy_rule', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_owner': type.OptionalType(type.ReferenceType(__name__, 'OwnerResourceLink')),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'action': type.OptionalType(type.StringType()),
        'destinations': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IPSecVPNPolicySubnet'))),
        'enabled': type.OptionalType(type.BooleanType()),
        'logged': type.OptionalType(type.BooleanType()),
        'sources': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IPSecVPNPolicySubnet'))),
    },
    IPSecVPNPolicyRule,
    False,
    None))



class IPSecVPNPolicySubnet(VapiStruct):
    """
    Used to specify the local/peer subnets in IPSec VPN Policy rule.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'subnet': 'subnet',
                            }

    def __init__(self,
                 subnet=None,
                ):
        """
        :type  subnet: :class:`str` or ``None``
        :param subnet: Subnet used in policy rule. format: ipv4-cidr-block
        """
        self.subnet = subnet
        VapiStruct.__init__(self)


IPSecVPNPolicySubnet._set_binding_type(type.StructType(
    'com.vmware.nsx.model.IP_sec_VPN_policy_subnet', {
        'subnet': type.OptionalType(type.StringType()),
    },
    IPSecVPNPolicySubnet,
    False,
    None))



class IPSecVPNPolicyTrafficStatistics(VapiStruct):
    """
    IPSec VPN policy traffic statistics

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'aggregate_traffic_counters': 'aggregate_traffic_counters',
                            'policy_id': 'policy_id',
                            'tunnel_port_id': 'tunnel_port_id',
                            'tunnel_statistics': 'tunnel_statistics',
                            }

    def __init__(self,
                 aggregate_traffic_counters=None,
                 policy_id=None,
                 tunnel_port_id=None,
                 tunnel_statistics=None,
                ):
        """
        :type  aggregate_traffic_counters: :class:`IPSecVPNTrafficCounters` or ``None``
        :param aggregate_traffic_counters: Aggregate traffic statistics across all ipsec tunnels.
        :type  policy_id: :class:`str` or ``None``
        :param policy_id: Policy Identifier.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  tunnel_port_id: :class:`str` or ``None``
        :param tunnel_port_id: Tunnel port identifier.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  tunnel_statistics: :class:`list` of :class:`IPSecVPNTunnelTrafficStatistics` or ``None``
        :param tunnel_statistics: Tunnel statistics.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.aggregate_traffic_counters = aggregate_traffic_counters
        self.policy_id = policy_id
        self.tunnel_port_id = tunnel_port_id
        self.tunnel_statistics = tunnel_statistics
        VapiStruct.__init__(self)


IPSecVPNPolicyTrafficStatistics._set_binding_type(type.StructType(
    'com.vmware.nsx.model.IP_sec_VPN_policy_traffic_statistics', {
        'aggregate_traffic_counters': type.OptionalType(type.ReferenceType(__name__, 'IPSecVPNTrafficCounters')),
        'policy_id': type.OptionalType(type.StringType()),
        'tunnel_port_id': type.OptionalType(type.StringType()),
        'tunnel_statistics': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IPSecVPNTunnelTrafficStatistics'))),
    },
    IPSecVPNPolicyTrafficStatistics,
    False,
    None))



class IPSecVPNService(VapiStruct):
    """
    Create and manage IPSec VPN service for given logical router.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    IKE_LOG_LEVEL_DEBUG = "DEBUG"
    """


    """
    IKE_LOG_LEVEL_INFO = "INFO"
    """


    """
    IKE_LOG_LEVEL_WARN = "WARN"
    """


    """
    IKE_LOG_LEVEL_ERROR = "ERROR"
    """


    """
    IKE_LOG_LEVEL_EMERGENCY = "EMERGENCY"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'bypass_rules': 'bypass_rules',
                            'enabled': 'enabled',
                            'ike_log_level': 'ike_log_level',
                            'ipsec_ha_sync': 'ipsec_ha_sync',
                            'logical_router_id': 'logical_router_id',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 bypass_rules=None,
                 enabled=None,
                 ike_log_level=None,
                 ipsec_ha_sync=None,
                 logical_router_id=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  bypass_rules: :class:`list` of :class:`IPSecVPNPolicyRule` or ``None``
        :param bypass_rules: Bypass policy rules are configured using VPN service. Bypass rules
            always have higher priority over protect rules and they affect all
            policy based vpn sessions associated with the IPSec VPN service.
            Protect rules are defined per policy based vpn session.
        :type  enabled: :class:`bool` or ``None``
        :param enabled: If true, enable VPN services for given logical router.
        :type  ike_log_level: :class:`str` or ``None``
        :param ike_log_level: Possible values are: 
            
            * :attr:`IPSecVPNService.IKE_LOG_LEVEL_DEBUG`
            * :attr:`IPSecVPNService.IKE_LOG_LEVEL_INFO`
            * :attr:`IPSecVPNService.IKE_LOG_LEVEL_WARN`
            * :attr:`IPSecVPNService.IKE_LOG_LEVEL_ERROR`
            * :attr:`IPSecVPNService.IKE_LOG_LEVEL_EMERGENCY`
            
             Log level for internet key exchange (IKE).
        :type  ipsec_ha_sync: :class:`bool` or ``None``
        :param ipsec_ha_sync: Enable/disable IPSec HA state sync. IPSec HA state sync can be
            disabled in case there are performance issues with the state sync
            messages. Default is to enable HA Sync.
        :type  logical_router_id: :class:`str` or ``None``
        :param logical_router_id: Logical router id.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.bypass_rules = bypass_rules
        self.enabled = enabled
        self.ike_log_level = ike_log_level
        self.ipsec_ha_sync = ipsec_ha_sync
        self.logical_router_id = logical_router_id
        VapiStruct.__init__(self)


IPSecVPNService._set_binding_type(type.StructType(
    'com.vmware.nsx.model.IP_sec_VPN_service', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'bypass_rules': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IPSecVPNPolicyRule'))),
        'enabled': type.OptionalType(type.BooleanType()),
        'ike_log_level': type.OptionalType(type.StringType()),
        'ipsec_ha_sync': type.OptionalType(type.BooleanType()),
        'logical_router_id': type.OptionalType(type.StringType()),
    },
    IPSecVPNService,
    False,
    None))



class IPSecVPNServiceListResult(VapiStruct):
    """
    List all the IPSec VPN services.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`IPSecVPNService` or ``None``
        :param results: IPSec VPN serivce list result
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


IPSecVPNServiceListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.IP_sec_VPN_service_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IPSecVPNService'))),
    },
    IPSecVPNServiceListResult,
    False,
    None))



class IPSecVPNSession(VapiStruct):
    """
    VPN session defines connection between local and peer endpoint. Untill VPN
    session is defined configuration is not realized.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "IPSecVPNSession"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    RESOURCE_TYPE_POLICYBASEDIPSECVPNSESSION = "PolicyBasedIPSecVPNSession"
    """


    """
    RESOURCE_TYPE_ROUTEBASEDIPSECVPNSESSION = "RouteBasedIPSecVPNSession"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'enabled': 'enabled',
                            'ipsec_vpn_service_id': 'ipsec_vpn_service_id',
                            'local_endpoint_id': 'local_endpoint_id',
                            'peer_endpoint_id': 'peer_endpoint_id',
                            'tcp_mss_clamping': 'tcp_mss_clamping',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='IPSecVPNSession',
                 tags=None,
                 enabled=None,
                 ipsec_vpn_service_id=None,
                 local_endpoint_id=None,
                 peer_endpoint_id=None,
                 tcp_mss_clamping=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`IPSecVPNSession.RESOURCE_TYPE_POLICYBASEDIPSECVPNSESSION`
            * :attr:`IPSecVPNSession.RESOURCE_TYPE_ROUTEBASEDIPSECVPNSESSION`
            
            A Policy Based VPN requires to define protect rules that match
            local and peer subnets. IPSec security associations is negotiated
            for each pair of local and peer subnet. A Route Based VPN is more
            flexible, more powerful and recommended over policy based VPN. IP
            Tunnel port is created and all traffic routed via tunnel port is
            protected. Routes can be configured statically or can be learned
            through BGP. A route based VPN is must for establishing redundant
            VPN session to remote site.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  enabled: :class:`bool` or ``None``
        :param enabled: Enable/Disable IPSec VPN session.
        :type  ipsec_vpn_service_id: :class:`str` or ``None``
        :param ipsec_vpn_service_id: Identifier of VPN Service linked with local endpoint.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  local_endpoint_id: :class:`str` or ``None``
        :param local_endpoint_id: Local endpoint identifier.
        :type  peer_endpoint_id: :class:`str` or ``None``
        :param peer_endpoint_id: Peer endpoint identifier.
        :type  tcp_mss_clamping: :class:`TcpMssClamping` or ``None``
        :param tcp_mss_clamping: 
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        self.enabled = enabled
        self.ipsec_vpn_service_id = ipsec_vpn_service_id
        self.local_endpoint_id = local_endpoint_id
        self.peer_endpoint_id = peer_endpoint_id
        self.tcp_mss_clamping = tcp_mss_clamping
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

IPSecVPNSession._set_binding_type(type.StructType(
    'com.vmware.nsx.model.IP_sec_VPN_session', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'enabled': type.OptionalType(type.BooleanType()),
        'ipsec_vpn_service_id': type.OptionalType(type.StringType()),
        'local_endpoint_id': type.OptionalType(type.StringType()),
        'peer_endpoint_id': type.OptionalType(type.StringType()),
        'tcp_mss_clamping': type.OptionalType(type.ReferenceType(__name__, 'TcpMssClamping')),
    },
    IPSecVPNSession,
    False,
    None))



class IPSecVPNSessionListResult(VapiStruct):
    """
    List all the IPSec VPN sessions.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param results: IPSec VPN sessions list result
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`IPSecVPNSession`. When methods return a value of this class
            as a return value, the attribute will contain all the attributes
            defined in :class:`IPSecVPNSession`.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


IPSecVPNSessionListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.IP_sec_VPN_session_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'IPSecVPNSession')]))),
    },
    IPSecVPNSessionListResult,
    False,
    None))



class IPSecVPNSessionState(VapiStruct):
    """
    This holds the state of IPSec VPN Session. If there are errors in realizing
    session outside of MP, it gives details of the components and specific
    errors.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATE_PENDING = "pending"
    """


    """
    STATE_IN_PROGRESS = "in_progress"
    """


    """
    STATE_SUCCESS = "success"
    """


    """
    STATE_FAILED = "failed"
    """


    """
    STATE_PARTIAL_SUCCESS = "partial_success"
    """


    """
    STATE_ORPHANED = "orphaned"
    """


    """
    STATE_UNKNOWN = "unknown"
    """


    """
    STATE_ERROR = "error"
    """


    """
    STATE_IN_SYNC = "in_sync"
    """


    """
    STATE_NOT_AVAILABLE = "NOT_AVAILABLE"
    """


    """
    STATE_VM_DEPLOYMENT_QUEUED = "VM_DEPLOYMENT_QUEUED"
    """


    """
    STATE_VM_DEPLOYMENT_IN_PROGRESS = "VM_DEPLOYMENT_IN_PROGRESS"
    """


    """
    STATE_VM_DEPLOYMENT_FAILED = "VM_DEPLOYMENT_FAILED"
    """


    """
    STATE_VM_POWER_ON_IN_PROGRESS = "VM_POWER_ON_IN_PROGRESS"
    """


    """
    STATE_VM_POWER_ON_FAILED = "VM_POWER_ON_FAILED"
    """


    """
    STATE_REGISTRATION_PENDING = "REGISTRATION_PENDING"
    """


    """
    STATE_NODE_NOT_READY = "NODE_NOT_READY"
    """


    """
    STATE_NODE_READY = "NODE_READY"
    """


    """
    STATE_VM_POWER_OFF_IN_PROGRESS = "VM_POWER_OFF_IN_PROGRESS"
    """


    """
    STATE_VM_POWER_OFF_FAILED = "VM_POWER_OFF_FAILED"
    """


    """
    STATE_VM_UNDEPLOY_IN_PROGRESS = "VM_UNDEPLOY_IN_PROGRESS"
    """


    """
    STATE_VM_UNDEPLOY_FAILED = "VM_UNDEPLOY_FAILED"
    """


    """
    STATE_VM_UNDEPLOY_SUCCESSFUL = "VM_UNDEPLOY_SUCCESSFUL"
    """


    """
    STATE_EDGE_CONFIG_ERROR = "EDGE_CONFIG_ERROR"
    """


    """
    STATE_VM_DEPLOYMENT_RESTARTED = "VM_DEPLOYMENT_RESTARTED"
    """


    """
    STATE_REGISTRATION_FAILED = "REGISTRATION_FAILED"
    """


    """
    STATE_TRANSPORT_NODE_SYNC_PENDING = "TRANSPORT_NODE_SYNC_PENDING"
    """


    """
    STATE_TRANSPORT_NODE_CONFIGURATION_MISSING = "TRANSPORT_NODE_CONFIGURATION_MISSING"
    """


    """
    STATE_EDGE_HARDWARE_NOT_SUPPORTED = "EDGE_HARDWARE_NOT_SUPPORTED"
    """


    """
    STATE_MULTIPLE_OVERLAY_TZS_NOT_SUPPORTED = "MULTIPLE_OVERLAY_TZS_NOT_SUPPORTED"
    """


    """
    STATE_TN_OVERLAY_TZ_IN_USE_BY_EDGE_CLUSTER = "TN_OVERLAY_TZ_IN_USE_BY_EDGE_CLUSTER"
    """


    """
    STATE_TZ_ENDPOINTS_NOT_SPECIFIED = "TZ_ENDPOINTS_NOT_SPECIFIED"
    """


    """
    STATE_NO_PNIC_PREPARED_IN_EDGE = "NO_PNIC_PREPARED_IN_EDGE"
    """


    """
    STATE_APPLIANCE_INTERNAL_ERROR = "APPLIANCE_INTERNAL_ERROR"
    """


    """
    STATE_VTEP_DHCP_NOT_SUPPORTED = "VTEP_DHCP_NOT_SUPPORTED"
    """


    """
    STATE_UNSUPPORTED_HOST_SWITCH_PROFILE = "UNSUPPORTED_HOST_SWITCH_PROFILE"
    """


    """
    STATE_UPLINK_HOST_SWITCH_PROFILE_NOT_SPECIFIED = "UPLINK_HOST_SWITCH_PROFILE_NOT_SPECIFIED"
    """


    """
    STATE_HOSTSWITCH_PROFILE_NOT_FOUND = "HOSTSWITCH_PROFILE_NOT_FOUND"
    """


    """
    STATE_LLDP_SEND_ENABLED_NOT_SUPPORTED = "LLDP_SEND_ENABLED_NOT_SUPPORTED"
    """


    """
    STATE_UNSUPPORTED_NAMED_TEAMING_POLICY = "UNSUPPORTED_NAMED_TEAMING_POLICY"
    """


    """
    STATE_LBSRCID_NOT_SUPPORTED_FOR_EDGE_VM = "LBSRCID_NOT_SUPPORTED_FOR_EDGE_VM"
    """


    """
    STATE_LACP_NOT_SUPPORTED_FOR_EDGE_VM = "LACP_NOT_SUPPORTED_FOR_EDGE_VM"
    """


    """
    STATE_STANDBY_UPLINKS_NOT_SUPPORTED_FOR_EDGE_VM = "STANDBY_UPLINKS_NOT_SUPPORTED_FOR_EDGE_VM"
    """


    """
    STATE_MULTIPLE_ACTIVE_UPLINKS_NOT_SUPPORTED_FOR_EDGE = "MULTIPLE_ACTIVE_UPLINKS_NOT_SUPPORTED_FOR_EDGE"
    """


    """
    STATE_UNSUPPORTED_LACP_LB_ALGO_FOR_NODE = "UNSUPPORTED_LACP_LB_ALGO_FOR_NODE"
    """


    """
    STATE_EDGE_NODE_VERSION_NOT_SUPPORTED = "EDGE_NODE_VERSION_NOT_SUPPORTED"
    """


    """
    STATE_NO_PNIC_SPECIFIED_IN_TN = "NO_PNIC_SPECIFIED_IN_TN"
    """


    """
    STATE_INVALID_PNIC_DEVICE_NAME = "INVALID_PNIC_DEVICE_NAME"
    """


    """
    STATE_TRANSPORT_NODE_READY = "TRANSPORT_NODE_READY"
    """


    """
    STATE_VM_NETWORK_EDIT_PENDING = "VM_NETWORK_EDIT_PENDING"
    """


    """
    STATE_UNSUPPORTED_DEFAULT_TEAMING_POLICY = "UNSUPPORTED_DEFAULT_TEAMING_POLICY"
    """


    """
    STATE_MPA_DISCONNECTED = "MPA_DISCONNECTED"
    """


    """
    STATE_VM_RENAME_PENDING = "VM_RENAME_PENDING"
    """


    """
    STATE_VM_CONFIG_EDIT_PENDING = "VM_CONFIG_EDIT_PENDING"
    """


    """
    STATE_VM_NETWORK_EDIT_FAILED = "VM_NETWORK_EDIT_FAILED"
    """


    """
    STATE_VM_RENAME_FAILED = "VM_RENAME_FAILED"
    """


    """
    STATE_VM_CONFIG_EDIT_FAILED = "VM_CONFIG_EDIT_FAILED"
    """


    """
    STATE_VM_CONFIG_DISCREPANCY = "VM_CONFIG_DISCREPANCY"
    """


    """
    STATE_VM_NODE_REFRESH_FAILED = "VM_NODE_REFRESH_FAILED"
    """


    """
    STATE_VM_PLACEMENT_REFRESH_FAILED = "VM_PLACEMENT_REFRESH_FAILED"
    """


    """
    STATE_REGISTRATION_TIMEDOUT = "REGISTRATION_TIMEDOUT"
    """


    """



    _canonical_to_pep_names = {
                            'details': 'details',
                            'failure_code': 'failure_code',
                            'failure_message': 'failure_message',
                            'state': 'state',
                            'pending_change_list': 'pending_change_list',
                            }

    def __init__(self,
                 details=None,
                 failure_code=None,
                 failure_message=None,
                 state=None,
                 pending_change_list=None,
                ):
        """
        :type  details: :class:`list` of :class:`ConfigurationStateElement` or ``None``
        :param details: Array of configuration state of various sub systems
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  failure_code: :class:`long` or ``None``
        :param failure_code: Error code format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  failure_message: :class:`str` or ``None``
        :param failure_message: Error message in case of failure
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  state: :class:`str` or ``None``
        :param state: Possible values are: 
            
            * :attr:`IPSecVPNSessionState.STATE_PENDING`
            * :attr:`IPSecVPNSessionState.STATE_IN_PROGRESS`
            * :attr:`IPSecVPNSessionState.STATE_SUCCESS`
            * :attr:`IPSecVPNSessionState.STATE_FAILED`
            * :attr:`IPSecVPNSessionState.STATE_PARTIAL_SUCCESS`
            * :attr:`IPSecVPNSessionState.STATE_ORPHANED`
            * :attr:`IPSecVPNSessionState.STATE_UNKNOWN`
            * :attr:`IPSecVPNSessionState.STATE_ERROR`
            * :attr:`IPSecVPNSessionState.STATE_IN_SYNC`
            * :attr:`IPSecVPNSessionState.STATE_NOT_AVAILABLE`
            * :attr:`IPSecVPNSessionState.STATE_VM_DEPLOYMENT_QUEUED`
            * :attr:`IPSecVPNSessionState.STATE_VM_DEPLOYMENT_IN_PROGRESS`
            * :attr:`IPSecVPNSessionState.STATE_VM_DEPLOYMENT_FAILED`
            * :attr:`IPSecVPNSessionState.STATE_VM_POWER_ON_IN_PROGRESS`
            * :attr:`IPSecVPNSessionState.STATE_VM_POWER_ON_FAILED`
            * :attr:`IPSecVPNSessionState.STATE_REGISTRATION_PENDING`
            * :attr:`IPSecVPNSessionState.STATE_NODE_NOT_READY`
            * :attr:`IPSecVPNSessionState.STATE_NODE_READY`
            * :attr:`IPSecVPNSessionState.STATE_VM_POWER_OFF_IN_PROGRESS`
            * :attr:`IPSecVPNSessionState.STATE_VM_POWER_OFF_FAILED`
            * :attr:`IPSecVPNSessionState.STATE_VM_UNDEPLOY_IN_PROGRESS`
            * :attr:`IPSecVPNSessionState.STATE_VM_UNDEPLOY_FAILED`
            * :attr:`IPSecVPNSessionState.STATE_VM_UNDEPLOY_SUCCESSFUL`
            * :attr:`IPSecVPNSessionState.STATE_EDGE_CONFIG_ERROR`
            * :attr:`IPSecVPNSessionState.STATE_VM_DEPLOYMENT_RESTARTED`
            * :attr:`IPSecVPNSessionState.STATE_REGISTRATION_FAILED`
            * :attr:`IPSecVPNSessionState.STATE_TRANSPORT_NODE_SYNC_PENDING`
            *
              :attr:`IPSecVPNSessionState.STATE_TRANSPORT_NODE_CONFIGURATION_MISSING`
            * :attr:`IPSecVPNSessionState.STATE_EDGE_HARDWARE_NOT_SUPPORTED`
            *
              :attr:`IPSecVPNSessionState.STATE_MULTIPLE_OVERLAY_TZS_NOT_SUPPORTED`
            *
              :attr:`IPSecVPNSessionState.STATE_TN_OVERLAY_TZ_IN_USE_BY_EDGE_CLUSTER`
            * :attr:`IPSecVPNSessionState.STATE_TZ_ENDPOINTS_NOT_SPECIFIED`
            * :attr:`IPSecVPNSessionState.STATE_NO_PNIC_PREPARED_IN_EDGE`
            * :attr:`IPSecVPNSessionState.STATE_APPLIANCE_INTERNAL_ERROR`
            * :attr:`IPSecVPNSessionState.STATE_VTEP_DHCP_NOT_SUPPORTED`
            *
              :attr:`IPSecVPNSessionState.STATE_UNSUPPORTED_HOST_SWITCH_PROFILE`
            *
              :attr:`IPSecVPNSessionState.STATE_UPLINK_HOST_SWITCH_PROFILE_NOT_SPECIFIED`
            * :attr:`IPSecVPNSessionState.STATE_HOSTSWITCH_PROFILE_NOT_FOUND`
            *
              :attr:`IPSecVPNSessionState.STATE_LLDP_SEND_ENABLED_NOT_SUPPORTED`
            *
              :attr:`IPSecVPNSessionState.STATE_UNSUPPORTED_NAMED_TEAMING_POLICY`
            *
              :attr:`IPSecVPNSessionState.STATE_LBSRCID_NOT_SUPPORTED_FOR_EDGE_VM`
            * :attr:`IPSecVPNSessionState.STATE_LACP_NOT_SUPPORTED_FOR_EDGE_VM`
            *
              :attr:`IPSecVPNSessionState.STATE_STANDBY_UPLINKS_NOT_SUPPORTED_FOR_EDGE_VM`
            *
              :attr:`IPSecVPNSessionState.STATE_MULTIPLE_ACTIVE_UPLINKS_NOT_SUPPORTED_FOR_EDGE`
            *
              :attr:`IPSecVPNSessionState.STATE_UNSUPPORTED_LACP_LB_ALGO_FOR_NODE`
            *
              :attr:`IPSecVPNSessionState.STATE_EDGE_NODE_VERSION_NOT_SUPPORTED`
            * :attr:`IPSecVPNSessionState.STATE_NO_PNIC_SPECIFIED_IN_TN`
            * :attr:`IPSecVPNSessionState.STATE_INVALID_PNIC_DEVICE_NAME`
            * :attr:`IPSecVPNSessionState.STATE_TRANSPORT_NODE_READY`
            * :attr:`IPSecVPNSessionState.STATE_VM_NETWORK_EDIT_PENDING`
            *
              :attr:`IPSecVPNSessionState.STATE_UNSUPPORTED_DEFAULT_TEAMING_POLICY`
            * :attr:`IPSecVPNSessionState.STATE_MPA_DISCONNECTED`
            * :attr:`IPSecVPNSessionState.STATE_VM_RENAME_PENDING`
            * :attr:`IPSecVPNSessionState.STATE_VM_CONFIG_EDIT_PENDING`
            * :attr:`IPSecVPNSessionState.STATE_VM_NETWORK_EDIT_FAILED`
            * :attr:`IPSecVPNSessionState.STATE_VM_RENAME_FAILED`
            * :attr:`IPSecVPNSessionState.STATE_VM_CONFIG_EDIT_FAILED`
            * :attr:`IPSecVPNSessionState.STATE_VM_CONFIG_DISCREPANCY`
            * :attr:`IPSecVPNSessionState.STATE_VM_NODE_REFRESH_FAILED`
            * :attr:`IPSecVPNSessionState.STATE_VM_PLACEMENT_REFRESH_FAILED`
            * :attr:`IPSecVPNSessionState.STATE_REGISTRATION_TIMEDOUT`
            
            Gives details of state of desired configuration. Additional enums
            with more details on progress/success/error states are sent for
            edge node. The success states are NODE_READY and
            TRANSPORT_NODE_READY, pending states are {VM_DEPLOYMENT_QUEUED,
            VM_DEPLOYMENT_IN_PROGRESS, REGISTRATION_PENDING} and other values
            indicate failures. \"in_sync\" state indicates that the desired
            configuration has been received by the host to which it applies,
            but is not yet in effect. When the configuration is actually in
            effect, the state will change to \"success\". Please note, failed
            state is deprecated.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  pending_change_list: :class:`list` of :class:`str` or ``None``
        :param pending_change_list: Request identifier of the API which modified the entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.details = details
        self.failure_code = failure_code
        self.failure_message = failure_message
        self.state = state
        self.pending_change_list = pending_change_list
        VapiStruct.__init__(self)


IPSecVPNSessionState._set_binding_type(type.StructType(
    'com.vmware.nsx.model.IP_sec_VPN_session_state', {
        'details': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ConfigurationStateElement'))),
        'failure_code': type.OptionalType(type.IntegerType()),
        'failure_message': type.OptionalType(type.StringType()),
        'state': type.OptionalType(type.StringType()),
        'pending_change_list': type.OptionalType(type.ListType(type.StringType())),
    },
    IPSecVPNSessionState,
    False,
    None))



class IPSecVPNSessionStatistics(VapiStruct):
    """
    Session statistics gives aggregated statistics of all policies for all the
    tunnels.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'aggregate_traffic_counters': 'aggregate_traffic_counters',
                            'display_name': 'display_name',
                            'ike_status': 'ike_status',
                            'ike_traffic_statistics': 'ike_traffic_statistics',
                            'ipsec_vpn_session_id': 'ipsec_vpn_session_id',
                            'last_update_timestamp': 'last_update_timestamp',
                            'partial_stats': 'partial_stats',
                            'policy_statistics': 'policy_statistics',
                            }

    def __init__(self,
                 aggregate_traffic_counters=None,
                 display_name=None,
                 ike_status=None,
                 ike_traffic_statistics=None,
                 ipsec_vpn_session_id=None,
                 last_update_timestamp=None,
                 partial_stats=None,
                 policy_statistics=None,
                ):
        """
        :type  aggregate_traffic_counters: :class:`IPSecVPNTrafficCounters` or ``None``
        :param aggregate_traffic_counters: Aggregate traffic statistics across all ipsec tunnels.
        :type  display_name: :class:`str` or ``None``
        :param display_name: Display name of vpn session.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  ike_status: :class:`IPSecVPNIKESessionStatus` or ``None``
        :param ike_status: Status for IPSec VPN IKE session UP/DOWN and fail reason if IKE
            session is down.
        :type  ike_traffic_statistics: :class:`IPSecVPNIKETrafficStatistics` or ``None``
        :param ike_traffic_statistics: Traffic statistics for IPSec VPN IKE session. Note - Not supported
            in this release.
        :type  ipsec_vpn_session_id: :class:`str` or ``None``
        :param ipsec_vpn_session_id: UUID of vpn session.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_update_timestamp: :class:`long` or ``None``
        :param last_update_timestamp: Timestamp when the data was last updated. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  partial_stats: :class:`bool` or ``None``
        :param partial_stats: Partial statistics if true specifies that the statistics are only
            from active node.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  policy_statistics: :class:`list` of :class:`IPSecVPNPolicyTrafficStatistics` or ``None``
        :param policy_statistics: Gives aggregate traffic statistics across all ipsec tunnels and
            individual tunnel statistics.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.aggregate_traffic_counters = aggregate_traffic_counters
        self.display_name = display_name
        self.ike_status = ike_status
        self.ike_traffic_statistics = ike_traffic_statistics
        self.ipsec_vpn_session_id = ipsec_vpn_session_id
        self.last_update_timestamp = last_update_timestamp
        self.partial_stats = partial_stats
        self.policy_statistics = policy_statistics
        VapiStruct.__init__(self)


IPSecVPNSessionStatistics._set_binding_type(type.StructType(
    'com.vmware.nsx.model.IP_sec_VPN_session_statistics', {
        'aggregate_traffic_counters': type.OptionalType(type.ReferenceType(__name__, 'IPSecVPNTrafficCounters')),
        'display_name': type.OptionalType(type.StringType()),
        'ike_status': type.OptionalType(type.ReferenceType(__name__, 'IPSecVPNIKESessionStatus')),
        'ike_traffic_statistics': type.OptionalType(type.ReferenceType(__name__, 'IPSecVPNIKETrafficStatistics')),
        'ipsec_vpn_session_id': type.OptionalType(type.StringType()),
        'last_update_timestamp': type.OptionalType(type.IntegerType()),
        'partial_stats': type.OptionalType(type.BooleanType()),
        'policy_statistics': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IPSecVPNPolicyTrafficStatistics'))),
    },
    IPSecVPNSessionStatistics,
    False,
    None))



class IPSecVPNSessionStatus(VapiStruct):
    """
    IKE session traffic summary provides IKE session status and aggregate of
    traffic across all tunnel.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    SESSION_STATUS_UP = "UP"
    """


    """
    SESSION_STATUS_DOWN = "DOWN"
    """


    """
    SESSION_STATUS_DEGRADED = "DEGRADED"
    """


    """



    _canonical_to_pep_names = {
                            'aggregate_traffic_counters': 'aggregate_traffic_counters',
                            'display_name': 'display_name',
                            'failed_tunnels': 'failed_tunnels',
                            'ike_status': 'ike_status',
                            'ipsec_vpn_session_id': 'ipsec_vpn_session_id',
                            'last_update_timestamp': 'last_update_timestamp',
                            'negotiated_tunnels': 'negotiated_tunnels',
                            'session_status': 'session_status',
                            'total_tunnels': 'total_tunnels',
                            }

    def __init__(self,
                 aggregate_traffic_counters=None,
                 display_name=None,
                 failed_tunnels=None,
                 ike_status=None,
                 ipsec_vpn_session_id=None,
                 last_update_timestamp=None,
                 negotiated_tunnels=None,
                 session_status=None,
                 total_tunnels=None,
                ):
        """
        :type  aggregate_traffic_counters: :class:`IPSecVPNTrafficCounters` or ``None``
        :param aggregate_traffic_counters: Aggregate traffic statistics across all ipsec tunnels.
        :type  display_name: :class:`str` or ``None``
        :param display_name: Display name of vpn session.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  failed_tunnels: :class:`long` or ``None``
        :param failed_tunnels: Number of failed tunnels. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  ike_status: :class:`IPSecVPNIKESessionStatus` or ``None``
        :param ike_status: Status for IPSec VPN IKE session UP/DOWN and fail reason if IKE
            session is down.
        :type  ipsec_vpn_session_id: :class:`str` or ``None``
        :param ipsec_vpn_session_id: UUID of vpn session.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_update_timestamp: :class:`long` or ``None``
        :param last_update_timestamp: Timestamp when the data was last updated. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  negotiated_tunnels: :class:`long` or ``None``
        :param negotiated_tunnels: Number of negotiated tunnels. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  session_status: :class:`str` or ``None``
        :param session_status: Possible values are: 
            
            * :attr:`IPSecVPNSessionStatus.SESSION_STATUS_UP`
            * :attr:`IPSecVPNSessionStatus.SESSION_STATUS_DOWN`
            * :attr:`IPSecVPNSessionStatus.SESSION_STATUS_DEGRADED`
            
            Gives session status consolidated using IKE status and tunnel
            status. It can be UP, DOWN, DEGRADED. If IKE and all tunnels are UP
            status will be UP, if all down it will be DOWN, otherwise it will
            be DEGRADED.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  total_tunnels: :class:`long` or ``None``
        :param total_tunnels: Total number of tunnels. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.aggregate_traffic_counters = aggregate_traffic_counters
        self.display_name = display_name
        self.failed_tunnels = failed_tunnels
        self.ike_status = ike_status
        self.ipsec_vpn_session_id = ipsec_vpn_session_id
        self.last_update_timestamp = last_update_timestamp
        self.negotiated_tunnels = negotiated_tunnels
        self.session_status = session_status
        self.total_tunnels = total_tunnels
        VapiStruct.__init__(self)


IPSecVPNSessionStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.IP_sec_VPN_session_status', {
        'aggregate_traffic_counters': type.OptionalType(type.ReferenceType(__name__, 'IPSecVPNTrafficCounters')),
        'display_name': type.OptionalType(type.StringType()),
        'failed_tunnels': type.OptionalType(type.IntegerType()),
        'ike_status': type.OptionalType(type.ReferenceType(__name__, 'IPSecVPNIKESessionStatus')),
        'ipsec_vpn_session_id': type.OptionalType(type.StringType()),
        'last_update_timestamp': type.OptionalType(type.IntegerType()),
        'negotiated_tunnels': type.OptionalType(type.IntegerType()),
        'session_status': type.OptionalType(type.StringType()),
        'total_tunnels': type.OptionalType(type.IntegerType()),
    },
    IPSecVPNSessionStatus,
    False,
    None))



class IPSecVPNSessionSummary(VapiStruct):
    """
    Summarized view of all selected IPSec VPN sessions.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'aggregate_traffic_counters': 'aggregate_traffic_counters',
                            'last_update_timestamp': 'last_update_timestamp',
                            'session_summary': 'session_summary',
                            'traffic_summary_per_session': 'traffic_summary_per_session',
                            }

    def __init__(self,
                 aggregate_traffic_counters=None,
                 last_update_timestamp=None,
                 session_summary=None,
                 traffic_summary_per_session=None,
                ):
        """
        :type  aggregate_traffic_counters: :class:`IPSecVPNTrafficCounters` or ``None``
        :param aggregate_traffic_counters: Aggregate traffic statistics across all selected sessions.
        :type  last_update_timestamp: :class:`long` or ``None``
        :param last_update_timestamp: Timestamp when the data was last updated. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  session_summary: :class:`IPsecVPNIKESessionSummary` or ``None``
        :param session_summary: Session summary for number of total, established, failed and
            degraded IPSec VPN sessions.
        :type  traffic_summary_per_session: :class:`list` of :class:`IPSecVPNSessionTrafficSummary` or ``None``
        :param traffic_summary_per_session: Traffic summary per session.
        """
        self.aggregate_traffic_counters = aggregate_traffic_counters
        self.last_update_timestamp = last_update_timestamp
        self.session_summary = session_summary
        self.traffic_summary_per_session = traffic_summary_per_session
        VapiStruct.__init__(self)


IPSecVPNSessionSummary._set_binding_type(type.StructType(
    'com.vmware.nsx.model.IP_sec_VPN_session_summary', {
        'aggregate_traffic_counters': type.OptionalType(type.ReferenceType(__name__, 'IPSecVPNTrafficCounters')),
        'last_update_timestamp': type.OptionalType(type.IntegerType()),
        'session_summary': type.OptionalType(type.ReferenceType(__name__, 'IPsecVPNIKESessionSummary')),
        'traffic_summary_per_session': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IPSecVPNSessionTrafficSummary'))),
    },
    IPSecVPNSessionSummary,
    False,
    None))



class IPSecVPNSessionTrafficSummary(VapiStruct):
    """
    IPSec VPN session traffic summary.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'ipsec_vpn_session': 'ipsec_vpn_session',
                            'traffic_counters': 'traffic_counters',
                            }

    def __init__(self,
                 ipsec_vpn_session=None,
                 traffic_counters=None,
                ):
        """
        :type  ipsec_vpn_session: :class:`ResourceReference` or ``None``
        :param ipsec_vpn_session: VPN Session.
        :type  traffic_counters: :class:`IPSecVPNTrafficCounters` or ``None``
        :param traffic_counters: Traffic stastics.
        """
        self.ipsec_vpn_session = ipsec_vpn_session
        self.traffic_counters = traffic_counters
        VapiStruct.__init__(self)


IPSecVPNSessionTrafficSummary._set_binding_type(type.StructType(
    'com.vmware.nsx.model.IP_sec_VPN_session_traffic_summary', {
        'ipsec_vpn_session': type.OptionalType(type.ReferenceType(__name__, 'ResourceReference')),
        'traffic_counters': type.OptionalType(type.ReferenceType(__name__, 'IPSecVPNTrafficCounters')),
    },
    IPSecVPNSessionTrafficSummary,
    False,
    None))



class IPSecVPNTrafficCounters(VapiStruct):
    """
    Traffic counters for IPSec VPN session.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'bytes_in': 'bytes_in',
                            'bytes_out': 'bytes_out',
                            'dropped_packets_in': 'dropped_packets_in',
                            'dropped_packets_out': 'dropped_packets_out',
                            'packets_in': 'packets_in',
                            'packets_out': 'packets_out',
                            }

    def __init__(self,
                 bytes_in=None,
                 bytes_out=None,
                 dropped_packets_in=None,
                 dropped_packets_out=None,
                 packets_in=None,
                 packets_out=None,
                ):
        """
        :type  bytes_in: :class:`long` or ``None``
        :param bytes_in: Total number of bytes recevied. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  bytes_out: :class:`long` or ``None``
        :param bytes_out: Total number of bytes sent. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  dropped_packets_in: :class:`long` or ``None``
        :param dropped_packets_in: Total number of incoming packets dropped on inbound security
            association. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  dropped_packets_out: :class:`long` or ``None``
        :param dropped_packets_out: Total number of outgoing packets dropped on outbound security
            association. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  packets_in: :class:`long` or ``None``
        :param packets_in: Total number of packets received. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  packets_out: :class:`long` or ``None``
        :param packets_out: Total number of packets sent. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.bytes_in = bytes_in
        self.bytes_out = bytes_out
        self.dropped_packets_in = dropped_packets_in
        self.dropped_packets_out = dropped_packets_out
        self.packets_in = packets_in
        self.packets_out = packets_out
        VapiStruct.__init__(self)


IPSecVPNTrafficCounters._set_binding_type(type.StructType(
    'com.vmware.nsx.model.IP_sec_VPN_traffic_counters', {
        'bytes_in': type.OptionalType(type.IntegerType()),
        'bytes_out': type.OptionalType(type.IntegerType()),
        'dropped_packets_in': type.OptionalType(type.IntegerType()),
        'dropped_packets_out': type.OptionalType(type.IntegerType()),
        'packets_in': type.OptionalType(type.IntegerType()),
        'packets_out': type.OptionalType(type.IntegerType()),
    },
    IPSecVPNTrafficCounters,
    False,
    None))



class IPSecVPNTransportStatus(VapiStruct):
    """
    Provides IPSec VPN session status.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "IPSecVPNTransportStatus"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'status': 'status',
                            'resource_type': 'resource_type',
                            'tunnel_id': 'tunnel_id',
                            }

    def __init__(self,
                 status=None,
                 resource_type='IPSecVPNTransportStatus',
                 tunnel_id=None,
                ):
        """
        :type  status: :class:`IPSecVPNSessionStatus` or ``None``
        :param status: VPN session status provides IKE session status and aggregate of
            traffic across all tunnel.
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            *
              :attr:`L2VPNTransportTunnelStatus.RESOURCE_TYPE_IPSECVPNTRANSPORTSTATUS`
            
             Resource types of L2VPN Transport tunnels
        :type  tunnel_id: :class:`ResourceReference` or ``None``
        :param tunnel_id: Transport tunnel id.
        """
        self.status = status
        self._resource_type = resource_type
        self.tunnel_id = tunnel_id
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

IPSecVPNTransportStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.IP_sec_VPN_transport_status', {
        'status': type.OptionalType(type.ReferenceType(__name__, 'IPSecVPNSessionStatus')),
        'resource_type': type.StringType(),
        'tunnel_id': type.OptionalType(type.ReferenceType(__name__, 'ResourceReference')),
    },
    IPSecVPNTransportStatus,
    False,
    None))



class IPSecVPNTunnelProfile(VapiStruct):
    """
    IPSec VPN tunnel profile is a reusable profile that captures phase two
    negotiation parameters and tunnel properties. Any changes affects all IPSec
    VPN sessions consuming this profile.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    DF_POLICY_COPY = "COPY"
    """


    """
    DF_POLICY_CLEAR = "CLEAR"
    """


    """
    DH_GROUPS_GROUP2 = "GROUP2"
    """


    """
    DH_GROUPS_GROUP5 = "GROUP5"
    """


    """
    DH_GROUPS_GROUP14 = "GROUP14"
    """


    """
    DH_GROUPS_GROUP15 = "GROUP15"
    """


    """
    DH_GROUPS_GROUP16 = "GROUP16"
    """


    """
    DH_GROUPS_GROUP19 = "GROUP19"
    """


    """
    DH_GROUPS_GROUP20 = "GROUP20"
    """


    """
    DH_GROUPS_GROUP21 = "GROUP21"
    """


    """
    DIGEST_ALGORITHMS_SHA1 = "SHA1"
    """


    """
    DIGEST_ALGORITHMS_SHA2_256 = "SHA2_256"
    """


    """
    DIGEST_ALGORITHMS_SHA2_384 = "SHA2_384"
    """


    """
    DIGEST_ALGORITHMS_SHA2_512 = "SHA2_512"
    """


    """
    ENCAPSULATION_MODE_MODE = "TUNNEL_MODE"
    """


    """
    ENCRYPTION_ALGORITHMS_AES_128 = "AES_128"
    """


    """
    ENCRYPTION_ALGORITHMS_AES_256 = "AES_256"
    """


    """
    ENCRYPTION_ALGORITHMS_AES_GCM_128 = "AES_GCM_128"
    """


    """
    ENCRYPTION_ALGORITHMS_AES_GCM_192 = "AES_GCM_192"
    """


    """
    ENCRYPTION_ALGORITHMS_AES_GCM_256 = "AES_GCM_256"
    """


    """
    ENCRYPTION_ALGORITHMS_NO_ENCRYPTION_AUTH_AES_GMAC_128 = "NO_ENCRYPTION_AUTH_AES_GMAC_128"
    """


    """
    ENCRYPTION_ALGORITHMS_NO_ENCRYPTION_AUTH_AES_GMAC_192 = "NO_ENCRYPTION_AUTH_AES_GMAC_192"
    """


    """
    ENCRYPTION_ALGORITHMS_NO_ENCRYPTION_AUTH_AES_GMAC_256 = "NO_ENCRYPTION_AUTH_AES_GMAC_256"
    """


    """
    ENCRYPTION_ALGORITHMS_NO_ENCRYPTION = "NO_ENCRYPTION"
    """


    """
    TRANSFORM_PROTOCOL_ESP = "ESP"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'df_policy': 'df_policy',
                            'dh_groups': 'dh_groups',
                            'digest_algorithms': 'digest_algorithms',
                            'enable_perfect_forward_secrecy': 'enable_perfect_forward_secrecy',
                            'encapsulation_mode': 'encapsulation_mode',
                            'encryption_algorithms': 'encryption_algorithms',
                            'sa_life_time': 'sa_life_time',
                            'transform_protocol': 'transform_protocol',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 df_policy=None,
                 dh_groups=None,
                 digest_algorithms=None,
                 enable_perfect_forward_secrecy=None,
                 encapsulation_mode=None,
                 encryption_algorithms=None,
                 sa_life_time=None,
                 transform_protocol=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  df_policy: :class:`str` or ``None``
        :param df_policy: Possible values are: 
            
            * :attr:`IPSecVPNTunnelProfile.DF_POLICY_COPY`
            * :attr:`IPSecVPNTunnelProfile.DF_POLICY_CLEAR`
            
            Defragmentation policy helps to handle defragmentation bit present
            in the inner packet. COPY copies the defragmentation bit from the
            inner IP packet into the outer packet. CLEAR ignores the
            defragmentation bit present in the inner packet.
        :type  dh_groups: :class:`list` of :class:`str` or ``None``
        :param dh_groups: Possible values are: 
            
            * :attr:`IPSecVPNTunnelProfile.DH_GROUPS_GROUP2`
            * :attr:`IPSecVPNTunnelProfile.DH_GROUPS_GROUP5`
            * :attr:`IPSecVPNTunnelProfile.DH_GROUPS_GROUP14`
            * :attr:`IPSecVPNTunnelProfile.DH_GROUPS_GROUP15`
            * :attr:`IPSecVPNTunnelProfile.DH_GROUPS_GROUP16`
            * :attr:`IPSecVPNTunnelProfile.DH_GROUPS_GROUP19`
            * :attr:`IPSecVPNTunnelProfile.DH_GROUPS_GROUP20`
            * :attr:`IPSecVPNTunnelProfile.DH_GROUPS_GROUP21`
            
            Diffie-Hellman group to be used if PFS is enabled. Default is
            GROUP14.
        :type  digest_algorithms: :class:`list` of :class:`str` or ``None``
        :param digest_algorithms: Possible values are: 
            
            * :attr:`IPSecVPNTunnelProfile.DIGEST_ALGORITHMS_SHA1`
            * :attr:`IPSecVPNTunnelProfile.DIGEST_ALGORITHMS_SHA2_256`
            * :attr:`IPSecVPNTunnelProfile.DIGEST_ALGORITHMS_SHA2_384`
            * :attr:`IPSecVPNTunnelProfile.DIGEST_ALGORITHMS_SHA2_512`
            
            Algorithm to be used for message digest. Default digest algorithm
            is implicitly covered by default encryption algorithm
            \"AES_GCM_128\".
        :type  enable_perfect_forward_secrecy: :class:`bool` or ``None``
        :param enable_perfect_forward_secrecy: If true, perfect forward secrecy (PFS) is enabled.
        :type  encapsulation_mode: :class:`str` or ``None``
        :param encapsulation_mode: Possible values are: 
            
            * :attr:`IPSecVPNTunnelProfile.ENCAPSULATION_MODE_MODE`
            
            Encapsulation Mode to be used for encryption of packet. Tunnel mode
            protects internal routing information by encrypting IP header of
            original packet.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  encryption_algorithms: :class:`list` of :class:`str` or ``None``
        :param encryption_algorithms: Possible values are: 
            
            * :attr:`IPSecVPNTunnelProfile.ENCRYPTION_ALGORITHMS_AES_128`
            * :attr:`IPSecVPNTunnelProfile.ENCRYPTION_ALGORITHMS_AES_256`
            * :attr:`IPSecVPNTunnelProfile.ENCRYPTION_ALGORITHMS_AES_GCM_128`
            * :attr:`IPSecVPNTunnelProfile.ENCRYPTION_ALGORITHMS_AES_GCM_192`
            * :attr:`IPSecVPNTunnelProfile.ENCRYPTION_ALGORITHMS_AES_GCM_256`
            *
              :attr:`IPSecVPNTunnelProfile.ENCRYPTION_ALGORITHMS_NO_ENCRYPTION_AUTH_AES_GMAC_128`
            *
              :attr:`IPSecVPNTunnelProfile.ENCRYPTION_ALGORITHMS_NO_ENCRYPTION_AUTH_AES_GMAC_192`
            *
              :attr:`IPSecVPNTunnelProfile.ENCRYPTION_ALGORITHMS_NO_ENCRYPTION_AUTH_AES_GMAC_256`
            * :attr:`IPSecVPNTunnelProfile.ENCRYPTION_ALGORITHMS_NO_ENCRYPTION`
            
            Encryption algorithm to encrypt/decrypt the messages exchanged
            between IPSec VPN initiator and responder during tunnel
            negotiation. Default is AES_GCM_128.
        :type  sa_life_time: :class:`long` or ``None``
        :param sa_life_time: SA life time specifies the expiry time of security association.
            Default is 3600 seconds. format: int64
        :type  transform_protocol: :class:`str` or ``None``
        :param transform_protocol: Possible values are: 
            
            * :attr:`IPSecVPNTunnelProfile.TRANSFORM_PROTOCOL_ESP`
            
             IPSec transform specifies IPSec security protocol.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.df_policy = df_policy
        self.dh_groups = dh_groups
        self.digest_algorithms = digest_algorithms
        self.enable_perfect_forward_secrecy = enable_perfect_forward_secrecy
        self.encapsulation_mode = encapsulation_mode
        self.encryption_algorithms = encryption_algorithms
        self.sa_life_time = sa_life_time
        self.transform_protocol = transform_protocol
        VapiStruct.__init__(self)


IPSecVPNTunnelProfile._set_binding_type(type.StructType(
    'com.vmware.nsx.model.IP_sec_VPN_tunnel_profile', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'df_policy': type.OptionalType(type.StringType()),
        'dh_groups': type.OptionalType(type.ListType(type.StringType())),
        'digest_algorithms': type.OptionalType(type.ListType(type.StringType())),
        'enable_perfect_forward_secrecy': type.OptionalType(type.BooleanType()),
        'encapsulation_mode': type.OptionalType(type.StringType()),
        'encryption_algorithms': type.OptionalType(type.ListType(type.StringType())),
        'sa_life_time': type.OptionalType(type.IntegerType()),
        'transform_protocol': type.OptionalType(type.StringType()),
    },
    IPSecVPNTunnelProfile,
    False,
    None))



class IPSecVPNTunnelProfileListResult(VapiStruct):
    """
    List all the tunnel profiles.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`IPSecVPNTunnelProfile` or ``None``
        :param results: IPSec Tunnel Profile list results
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


IPSecVPNTunnelProfileListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.IP_sec_VPN_tunnel_profile_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IPSecVPNTunnelProfile'))),
    },
    IPSecVPNTunnelProfileListResult,
    False,
    None))



class IPSecVPNTunnelTrafficStatistics(VapiStruct):
    """
    IPSec VPN tunnel traffic statistics.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    TUNNEL_STATUS_UP = "UP"
    """


    """
    TUNNEL_STATUS_DOWN = "DOWN"
    """


    """
    TUNNEL_STATUS_NEGOTIATING = "NEGOTIATING"
    """


    """



    _canonical_to_pep_names = {
                            'bytes_in': 'bytes_in',
                            'bytes_out': 'bytes_out',
                            'decryption_failures': 'decryption_failures',
                            'dropped_packets_in': 'dropped_packets_in',
                            'dropped_packets_out': 'dropped_packets_out',
                            'encryption_failures': 'encryption_failures',
                            'integrity_failures': 'integrity_failures',
                            'local_subnet': 'local_subnet',
                            'nomatching_policy_errors': 'nomatching_policy_errors',
                            'packets_in': 'packets_in',
                            'packets_out': 'packets_out',
                            'packets_receive_other_error': 'packets_receive_other_error',
                            'packets_sent_other_error': 'packets_sent_other_error',
                            'peer_subnet': 'peer_subnet',
                            'replay_errors': 'replay_errors',
                            'sa_mismatch_errors_in': 'sa_mismatch_errors_in',
                            'sa_mismatch_errors_out': 'sa_mismatch_errors_out',
                            'seq_number_overflow_error': 'seq_number_overflow_error',
                            'tunnel_down_reason': 'tunnel_down_reason',
                            'tunnel_status': 'tunnel_status',
                            }

    def __init__(self,
                 bytes_in=None,
                 bytes_out=None,
                 decryption_failures=None,
                 dropped_packets_in=None,
                 dropped_packets_out=None,
                 encryption_failures=None,
                 integrity_failures=None,
                 local_subnet=None,
                 nomatching_policy_errors=None,
                 packets_in=None,
                 packets_out=None,
                 packets_receive_other_error=None,
                 packets_sent_other_error=None,
                 peer_subnet=None,
                 replay_errors=None,
                 sa_mismatch_errors_in=None,
                 sa_mismatch_errors_out=None,
                 seq_number_overflow_error=None,
                 tunnel_down_reason=None,
                 tunnel_status=None,
                ):
        """
        :type  bytes_in: :class:`long` or ``None``
        :param bytes_in: Total number of incoming bytes on inbound Security association
            (SA). format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  bytes_out: :class:`long` or ``None``
        :param bytes_out: Total number of outgoing bytes on outbound Security association
            (SA). format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  decryption_failures: :class:`long` or ``None``
        :param decryption_failures: Total number of packets dropped due to decryption failures. format:
            int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  dropped_packets_in: :class:`long` or ``None``
        :param dropped_packets_in: Total number of incoming packets dropped on inbound security
            association. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  dropped_packets_out: :class:`long` or ``None``
        :param dropped_packets_out: Total number of outgoing packets dropped on outbound security
            association. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  encryption_failures: :class:`long` or ``None``
        :param encryption_failures: Total number of packets dropped because of failure in encryption.
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  integrity_failures: :class:`long` or ``None``
        :param integrity_failures: Total number of packets dropped due to integrity failures. format:
            int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  local_subnet: :class:`str` or ``None``
        :param local_subnet: Local subnet to which a tunnel belongs.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  nomatching_policy_errors: :class:`long` or ``None``
        :param nomatching_policy_errors: Number of packets dropped because of no matching policy is
            available. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  packets_in: :class:`long` or ``None``
        :param packets_in: Total number of incoming packets on inbound Security association
            (SA). format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  packets_out: :class:`long` or ``None``
        :param packets_out: Total number of outgoing packets on outbound Security association
            (SA). format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  packets_receive_other_error: :class:`long` or ``None``
        :param packets_receive_other_error: Total number of incoming packets dropped on inbound Security
            association (SA)(misc). format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  packets_sent_other_error: :class:`long` or ``None``
        :param packets_sent_other_error: Total number of packets dropped while sending for any reason.
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  peer_subnet: :class:`str` or ``None``
        :param peer_subnet: Peer subnet to which a tunnel belongs.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  replay_errors: :class:`long` or ``None``
        :param replay_errors: Total number of packets dropped due to replay check on that
            Security association (SA). format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sa_mismatch_errors_in: :class:`long` or ``None``
        :param sa_mismatch_errors_in: Totoal number of security association (SA) mismatch errors on
            incoming packets. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sa_mismatch_errors_out: :class:`long` or ``None``
        :param sa_mismatch_errors_out: Totoal number of security association (SA) mismatch errors on
            outgoing packets. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  seq_number_overflow_error: :class:`long` or ``None``
        :param seq_number_overflow_error: Total number of packets dropped while sending due to overflow in
            sequence number. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  tunnel_down_reason: :class:`str` or ``None``
        :param tunnel_down_reason: Gives the detailed reason about the tunnel when it is down. If
            tunnel is UP tunnel down reason will be empty.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  tunnel_status: :class:`str` or ``None``
        :param tunnel_status: Possible values are: 
            
            * :attr:`IPSecVPNTunnelTrafficStatistics.TUNNEL_STATUS_UP`
            * :attr:`IPSecVPNTunnelTrafficStatistics.TUNNEL_STATUS_DOWN`
            * :attr:`IPSecVPNTunnelTrafficStatistics.TUNNEL_STATUS_NEGOTIATING`
            
            Specifies the status of tunnel. If all the SA (Security
            association) are negotiated then tunnels status will be UP. If
            negotiation fails for the SAs status will be DOWN, if SAs are in
            negotiating phase tunnels status will be NEGOTIATING.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.bytes_in = bytes_in
        self.bytes_out = bytes_out
        self.decryption_failures = decryption_failures
        self.dropped_packets_in = dropped_packets_in
        self.dropped_packets_out = dropped_packets_out
        self.encryption_failures = encryption_failures
        self.integrity_failures = integrity_failures
        self.local_subnet = local_subnet
        self.nomatching_policy_errors = nomatching_policy_errors
        self.packets_in = packets_in
        self.packets_out = packets_out
        self.packets_receive_other_error = packets_receive_other_error
        self.packets_sent_other_error = packets_sent_other_error
        self.peer_subnet = peer_subnet
        self.replay_errors = replay_errors
        self.sa_mismatch_errors_in = sa_mismatch_errors_in
        self.sa_mismatch_errors_out = sa_mismatch_errors_out
        self.seq_number_overflow_error = seq_number_overflow_error
        self.tunnel_down_reason = tunnel_down_reason
        self.tunnel_status = tunnel_status
        VapiStruct.__init__(self)


IPSecVPNTunnelTrafficStatistics._set_binding_type(type.StructType(
    'com.vmware.nsx.model.IP_sec_VPN_tunnel_traffic_statistics', {
        'bytes_in': type.OptionalType(type.IntegerType()),
        'bytes_out': type.OptionalType(type.IntegerType()),
        'decryption_failures': type.OptionalType(type.IntegerType()),
        'dropped_packets_in': type.OptionalType(type.IntegerType()),
        'dropped_packets_out': type.OptionalType(type.IntegerType()),
        'encryption_failures': type.OptionalType(type.IntegerType()),
        'integrity_failures': type.OptionalType(type.IntegerType()),
        'local_subnet': type.OptionalType(type.StringType()),
        'nomatching_policy_errors': type.OptionalType(type.IntegerType()),
        'packets_in': type.OptionalType(type.IntegerType()),
        'packets_out': type.OptionalType(type.IntegerType()),
        'packets_receive_other_error': type.OptionalType(type.IntegerType()),
        'packets_sent_other_error': type.OptionalType(type.IntegerType()),
        'peer_subnet': type.OptionalType(type.StringType()),
        'replay_errors': type.OptionalType(type.IntegerType()),
        'sa_mismatch_errors_in': type.OptionalType(type.IntegerType()),
        'sa_mismatch_errors_out': type.OptionalType(type.IntegerType()),
        'seq_number_overflow_error': type.OptionalType(type.IntegerType()),
        'tunnel_down_reason': type.OptionalType(type.StringType()),
        'tunnel_status': type.OptionalType(type.StringType()),
    },
    IPSecVPNTunnelTrafficStatistics,
    False,
    None))



class IPSet(VapiStruct):
    """
    IPSet is used to group individual IP addresses, range of IP addresses or
    subnets. An IPSet is a homogeneous group of IP addresses, either of type
    IPv4 or of type IPv6. IPSets can be used as source or destination in
    firewall rules. These can also be used as members of NSGroups.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'ip_addresses': 'ip_addresses',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 ip_addresses=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  ip_addresses: :class:`list` of :class:`str` or ``None``
        :param ip_addresses: IP addresses format: address-or-block-or-range
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.ip_addresses = ip_addresses
        VapiStruct.__init__(self)


IPSet._set_binding_type(type.StructType(
    'com.vmware.nsx.model.IP_set', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'ip_addresses': type.OptionalType(type.ListType(type.StringType())),
    },
    IPSet,
    False,
    None))



class IPSetListResult(VapiStruct):
    """
    Paged collection of IPSets

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`IPSet` or ``None``
        :param results: IPSet list results
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


IPSetListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.IP_set_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IPSet'))),
    },
    IPSetListResult,
    False,
    None))



class IPSubnet(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'ip_addresses': 'ip_addresses',
                            'prefix_length': 'prefix_length',
                            }

    def __init__(self,
                 ip_addresses=None,
                 prefix_length=None,
                ):
        """
        :type  ip_addresses: :class:`list` of :class:`str` or ``None``
        :param ip_addresses: All IP addresses, some of which may be automatically configured.
            When updating this field, the payload may contain only the IP
            addresses that should be changed, or may contain the IP addresses
            to change as well as the automatically assigned addresses.
            Currently, only one updatable address and one system-maintained
            address are supported. Currently, the system-maintained address
            supported is Extended Unique Identifier(EUI)-64 address. EUI-64
            address is generated by the system only when user configured
            ip-subnet has prefix length less than or equal to 64. format: ip
        :type  prefix_length: :class:`long` or ``None``
        :param prefix_length: Subnet Prefix Length format: int64
        """
        self.ip_addresses = ip_addresses
        self.prefix_length = prefix_length
        VapiStruct.__init__(self)


IPSubnet._set_binding_type(type.StructType(
    'com.vmware.nsx.model.IP_subnet', {
        'ip_addresses': type.OptionalType(type.ListType(type.StringType())),
        'prefix_length': type.OptionalType(type.IntegerType()),
    },
    IPSubnet,
    False,
    None))



class IPsecVPNIKESessionSummary(VapiStruct):
    """
    IPSec VPN session status summary, gives total, failed, degraded and
    established IPSec VPN sessions.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'degraded_sessions': 'degraded_sessions',
                            'established_sessions': 'established_sessions',
                            'failed_sessions': 'failed_sessions',
                            'total_sessions': 'total_sessions',
                            }

    def __init__(self,
                 degraded_sessions=None,
                 established_sessions=None,
                 failed_sessions=None,
                 total_sessions=None,
                ):
        """
        :type  degraded_sessions: :class:`long` or ``None``
        :param degraded_sessions: Number of degraded sessions. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  established_sessions: :class:`long` or ``None``
        :param established_sessions: Number of established sessions. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  failed_sessions: :class:`long` or ``None``
        :param failed_sessions: Number of failed sessions. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  total_sessions: :class:`long` or ``None``
        :param total_sessions: Total sessions configured. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.degraded_sessions = degraded_sessions
        self.established_sessions = established_sessions
        self.failed_sessions = failed_sessions
        self.total_sessions = total_sessions
        VapiStruct.__init__(self)


IPsecVPNIKESessionSummary._set_binding_type(type.StructType(
    'com.vmware.nsx.model.I_psec_VPNIKE_session_summary', {
        'degraded_sessions': type.OptionalType(type.IntegerType()),
        'established_sessions': type.OptionalType(type.IntegerType()),
        'failed_sessions': type.OptionalType(type.IntegerType()),
        'total_sessions': type.OptionalType(type.IntegerType()),
    },
    IPsecVPNIKESessionSummary,
    False,
    None))



class IPv4AddressProperties(VapiStruct):
    """
    IPv4 address properties

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'ip_address': 'ip_address',
                            'netmask': 'netmask',
                            }

    def __init__(self,
                 ip_address=None,
                 netmask=None,
                ):
        """
        :type  ip_address: :class:`str` or ``None``
        :param ip_address: Interface IPv4 address
        :type  netmask: :class:`str` or ``None``
        :param netmask: Interface netmask
        """
        self.ip_address = ip_address
        self.netmask = netmask
        VapiStruct.__init__(self)


IPv4AddressProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.I_pv4_address_properties', {
        'ip_address': type.OptionalType(type.StringType()),
        'netmask': type.OptionalType(type.StringType()),
    },
    IPv4AddressProperties,
    False,
    None))



class IPv4DhcpServer(VapiStruct):
    """
    DHCP server to support IPv4 DHCP service. Properties defined at DHCP server
    level can be overridden by ip-pool or static-binding level properties.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'dhcp_server_ip': 'dhcp_server_ip',
                            'dns_nameservers': 'dns_nameservers',
                            'domain_name': 'domain_name',
                            'gateway_ip': 'gateway_ip',
                            'monitor_ippool_usage': 'monitor_ippool_usage',
                            'options': 'options',
                            }

    def __init__(self,
                 dhcp_server_ip=None,
                 dns_nameservers=None,
                 domain_name=None,
                 gateway_ip=None,
                 monitor_ippool_usage=None,
                 options=None,
                ):
        """
        :type  dhcp_server_ip: :class:`str` or ``None``
        :param dhcp_server_ip: DHCP server ip in CIDR format. format: ipv4-cidr-block
        :type  dns_nameservers: :class:`list` of :class:`str` or ``None``
        :param dns_nameservers: Primary and secondary DNS server address to assign host. They can
            be overridden by ip-pool or static-binding level property. format:
            ipv4
        :type  domain_name: :class:`str` or ``None``
        :param domain_name: Host name or prefix to be assigned to host. It can be overridden by
            ip-pool or static-binding level property. format: hostname
        :type  gateway_ip: :class:`str` or ``None``
        :param gateway_ip: Gateway ip to be assigned to host. It can be overridden by ip-pool
            or static-binding level property. format: ipv4
        :type  monitor_ippool_usage: :class:`bool` or ``None``
        :param monitor_ippool_usage: Enable or disable monitoring of DHCP ip-pools usage. When enabled,
            system events are generated when pool usage exceeds the configured
            thresholds. System events can be viewed in REST API
            /api/v2/hpm/alarms
        :type  options: :class:`DhcpOptions` or ``None``
        :param options: Defines the default options for all ip-pools and static-bindings of
            this server. These options will be ignored if options are defined
            for ip-pools or static-bindings.
        """
        self.dhcp_server_ip = dhcp_server_ip
        self.dns_nameservers = dns_nameservers
        self.domain_name = domain_name
        self.gateway_ip = gateway_ip
        self.monitor_ippool_usage = monitor_ippool_usage
        self.options = options
        VapiStruct.__init__(self)


IPv4DhcpServer._set_binding_type(type.StructType(
    'com.vmware.nsx.model.I_pv4_dhcp_server', {
        'dhcp_server_ip': type.OptionalType(type.StringType()),
        'dns_nameservers': type.OptionalType(type.ListType(type.StringType())),
        'domain_name': type.OptionalType(type.StringType()),
        'gateway_ip': type.OptionalType(type.StringType()),
        'monitor_ippool_usage': type.OptionalType(type.BooleanType()),
        'options': type.OptionalType(type.ReferenceType(__name__, 'DhcpOptions')),
    },
    IPv4DhcpServer,
    False,
    None))



class IPv6DADStatus(VapiStruct):
    """
    IPv6 DAD status

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATUS_DUPLICATED = "DUPLICATED"
    """


    """
    STATUS_TENTATIVE = "TENTATIVE"
    """


    """
    STATUS_ASSIGNED = "ASSIGNED"
    """


    """
    STATUS_NOT_APPLICABLE = "NOT_APPLICABLE"
    """


    """
    STATUS_UNKNOWN = "UNKNOWN"
    """


    """



    _canonical_to_pep_names = {
                            'ip_address': 'ip_address',
                            'status': 'status',
                            'transport_node': 'transport_node',
                            }

    def __init__(self,
                 ip_address=None,
                 status=None,
                 transport_node=None,
                ):
        """
        :type  ip_address: :class:`str` or ``None``
        :param ip_address: IP address on the port for which DAD status is reported. format: ip
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  status: :class:`str` or ``None``
        :param status: Possible values are: 
            
            * :attr:`IPv6DADStatus.STATUS_DUPLICATED`
            * :attr:`IPv6DADStatus.STATUS_TENTATIVE`
            * :attr:`IPv6DADStatus.STATUS_ASSIGNED`
            * :attr:`IPv6DADStatus.STATUS_NOT_APPLICABLE`
            * :attr:`IPv6DADStatus.STATUS_UNKNOWN`
            
             DAD status for IP address on the port.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  transport_node: :class:`list` of :class:`ResourceReference` or ``None``
        :param transport_node: Array of transport node id on which DAD status is reported for
            given IP address.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.ip_address = ip_address
        self.status = status
        self.transport_node = transport_node
        VapiStruct.__init__(self)


IPv6DADStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.I_pv6_DAD_status', {
        'ip_address': type.OptionalType(type.StringType()),
        'status': type.OptionalType(type.StringType()),
        'transport_node': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceReference'))),
    },
    IPv6DADStatus,
    False,
    None))



class IPv6DhcpServer(VapiStruct):
    """
    DHCP server to support IPv6 DHCP service. Properties defined at DHCP server
    level can be overridden by ip-pool or static-binding level properties.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'dhcp_server_ip': 'dhcp_server_ip',
                            'dns_nameservers': 'dns_nameservers',
                            'domain_names': 'domain_names',
                            'server_id': 'server_id',
                            'sntp_servers': 'sntp_servers',
                            }

    def __init__(self,
                 dhcp_server_ip=None,
                 dns_nameservers=None,
                 domain_names=None,
                 server_id=None,
                 sntp_servers=None,
                ):
        """
        :type  dhcp_server_ip: :class:`str` or ``None``
        :param dhcp_server_ip: DHCP server ip in CIDR format. format: ipv6-cidr-block
        :type  dns_nameservers: :class:`list` of :class:`str` or ``None``
        :param dns_nameservers: Primary and secondary DNS server address to assign host. They can
            be overridden by ip-pool or static-binding level property. format:
            ipv6
        :type  domain_names: :class:`list` of :class:`str` or ``None``
        :param domain_names: Host name or prefix to be assigned to host. It can be overridden by
            ip-pool or static-binding level property.
        :type  server_id: :class:`str` or ``None``
        :param server_id: DHCP server id.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sntp_servers: :class:`list` of :class:`str` or ``None``
        :param sntp_servers: SNTP server ips. format: ipv6
        """
        self.dhcp_server_ip = dhcp_server_ip
        self.dns_nameservers = dns_nameservers
        self.domain_names = domain_names
        self.server_id = server_id
        self.sntp_servers = sntp_servers
        VapiStruct.__init__(self)


IPv6DhcpServer._set_binding_type(type.StructType(
    'com.vmware.nsx.model.I_pv6_dhcp_server', {
        'dhcp_server_ip': type.OptionalType(type.StringType()),
        'dns_nameservers': type.OptionalType(type.ListType(type.StringType())),
        'domain_names': type.OptionalType(type.ListType(type.StringType())),
        'server_id': type.OptionalType(type.StringType()),
        'sntp_servers': type.OptionalType(type.ListType(type.StringType())),
    },
    IPv6DhcpServer,
    False,
    None))



class IPv6Profiles(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'dad_profile_id': 'dad_profile_id',
                            'ndra_profile_id': 'ndra_profile_id',
                            }

    def __init__(self,
                 dad_profile_id=None,
                 ndra_profile_id=None,
                ):
        """
        :type  dad_profile_id: :class:`str` or ``None``
        :param dad_profile_id: Identifier of Duplicate Address Detection profile. DAD profile has
            various configurations related to duplicate address detection. If
            no profile is associated manually to the router, then the system
            defined default DAD profile will be automatically applied.
        :type  ndra_profile_id: :class:`str` or ``None``
        :param ndra_profile_id: Identifier of Neighbor Discovery Router Advertisement profile. NDRA
            profile has various configurations required for router
            advertisement. If no profile is associated manually to the router,
            then the system defined default NDRA profile will be automatically
            applied.
        """
        self.dad_profile_id = dad_profile_id
        self.ndra_profile_id = ndra_profile_id
        VapiStruct.__init__(self)


IPv6Profiles._set_binding_type(type.StructType(
    'com.vmware.nsx.model.I_pv6_profiles', {
        'dad_profile_id': type.OptionalType(type.StringType()),
        'ndra_profile_id': type.OptionalType(type.StringType()),
    },
    IPv6Profiles,
    False,
    None))



class IcmpEchoRequestHeader(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'id': 'id',
                            'sequence': 'sequence',
                            }

    def __init__(self,
                 id=None,
                 sequence=None,
                ):
        """
        :type  id: :class:`long` or ``None``
        :param id: ICMP id format: int64
        :type  sequence: :class:`long` or ``None``
        :param sequence: ICMP sequence number format: int64
        """
        self.id = id
        self.sequence = sequence
        VapiStruct.__init__(self)


IcmpEchoRequestHeader._set_binding_type(type.StructType(
    'com.vmware.nsx.model.icmp_echo_request_header', {
        'id': type.OptionalType(type.IntegerType()),
        'sequence': type.OptionalType(type.IntegerType()),
    },
    IcmpEchoRequestHeader,
    False,
    None))



class Icon(VapiStruct):
    """
    Icon to be applied at dashboard for widgets and UI elements.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    PLACEMENT_PRE = "PRE"
    """


    """
    PLACEMENT_POST = "POST"
    """


    """
    TYPE_ERROR = "ERROR"
    """


    """
    TYPE_WARNING = "WARNING"
    """


    """
    TYPE_INFO = "INFO"
    """


    """
    TYPE_INPROGRESS = "INPROGRESS"
    """


    """
    TYPE_SUCCESS = "SUCCESS"
    """


    """
    TYPE_DETAIL = "DETAIL"
    """


    """
    TYPE_NOT_AVAILABLE = "NOT_AVAILABLE"
    """


    """
    TYPE_SECURITY = "SECURITY"
    """


    """
    TYPE_NETWORKING = "NETWORKING"
    """


    """
    TYPE_LOAD_BALANCER = "LOAD_BALANCER"
    """


    """
    TYPE_VPN = "VPN"
    """


    """
    TYPE_DOMAIN = "DOMAIN"
    """


    """
    TYPE_GROUP = "GROUP"
    """


    """
    TYPE_DISTRIBUTED_FIREWALL = "DISTRIBUTED_FIREWALL"
    """


    """
    TYPE_NETWORKING_TIER0 = "NETWORKING_TIER0"
    """


    """
    TYPE_NETWORKING_TIER1 = "NETWORKING_TIER1"
    """


    """
    TYPE_SEGMENT = "SEGMENT"
    """


    """
    TYPE_SYSTEM = "SYSTEM"
    """


    """
    TYPE_SYSTEM_FABRIC = "SYSTEM_FABRIC"
    """


    """
    TYPE_SYSTEM_BACKUPRESTORE = "SYSTEM_BACKUPRESTORE"
    """


    """
    TYPE_INVENTORY_GROUPS = "INVENTORY_GROUPS"
    """


    """
    TYPE_SECURITY_DFW = "SECURITY_DFW"
    """


    """



    _canonical_to_pep_names = {
                            'placement': 'placement',
                            'tooltip': 'tooltip',
                            'type': 'type',
                            }

    def __init__(self,
                 placement=None,
                 tooltip=None,
                 type=None,
                ):
        """
        :type  placement: :class:`str` or ``None``
        :param placement: Possible values are: 
            
            * :attr:`Icon.PLACEMENT_PRE`
            * :attr:`Icon.PLACEMENT_POST`
            
            If specified as PRE, the icon appears before the UI element. If set
            as POST, the icon appears after the UI element.
        :type  tooltip: :class:`list` of :class:`Tooltip` or ``None``
        :param tooltip: Multi-line text to be shown on tooltip while hovering over the
            icon.
        :type  type: :class:`str` or ``None``
        :param type: Possible values are: 
            
            * :attr:`Icon.TYPE_ERROR`
            * :attr:`Icon.TYPE_WARNING`
            * :attr:`Icon.TYPE_INFO`
            * :attr:`Icon.TYPE_INPROGRESS`
            * :attr:`Icon.TYPE_SUCCESS`
            * :attr:`Icon.TYPE_DETAIL`
            * :attr:`Icon.TYPE_NOT_AVAILABLE`
            * :attr:`Icon.TYPE_SECURITY`
            * :attr:`Icon.TYPE_NETWORKING`
            * :attr:`Icon.TYPE_LOAD_BALANCER`
            * :attr:`Icon.TYPE_VPN`
            * :attr:`Icon.TYPE_DOMAIN`
            * :attr:`Icon.TYPE_GROUP`
            * :attr:`Icon.TYPE_DISTRIBUTED_FIREWALL`
            * :attr:`Icon.TYPE_NETWORKING_TIER0`
            * :attr:`Icon.TYPE_NETWORKING_TIER1`
            * :attr:`Icon.TYPE_SEGMENT`
            * :attr:`Icon.TYPE_SYSTEM`
            * :attr:`Icon.TYPE_SYSTEM_FABRIC`
            * :attr:`Icon.TYPE_SYSTEM_BACKUPRESTORE`
            * :attr:`Icon.TYPE_INVENTORY_GROUPS`
            * :attr:`Icon.TYPE_SECURITY_DFW`
            
            Icon will be rendered based on its type. For example, if ERROR is
            chosen, then icon representing error will be rendered.
        """
        self.placement = placement
        self.tooltip = tooltip
        self.type = type
        VapiStruct.__init__(self)


Icon._set_binding_type(type.StructType(
    'com.vmware.nsx.model.icon', {
        'placement': type.OptionalType(type.StringType()),
        'tooltip': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tooltip'))),
        'type': type.OptionalType(type.StringType()),
    },
    Icon,
    False,
    None))



class IdfwComputeCollectionCondition(VapiStruct):
    """
    Status of the Identity Firewall enabled Compute collection.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATUS_UNKNOWN = "UNKNOWN"
    """


    """
    STATUS_UP = "UP"
    """


    """
    STATUS_DOWN = "DOWN"
    """


    """
    STATUS_DFW_DISABLED = "DFW_DISABLED"
    """


    """
    STATUS_IDFW_DISABLED = "IDFW_DISABLED"
    """


    """



    _canonical_to_pep_names = {
                            'status': 'status',
                            'status_detail': 'status_detail',
                            }

    def __init__(self,
                 status=None,
                 status_detail=None,
                ):
        """
        :type  status: :class:`str` or ``None``
        :param status: Possible values are: 
            
            * :attr:`IdfwComputeCollectionCondition.STATUS_UNKNOWN`
            * :attr:`IdfwComputeCollectionCondition.STATUS_UP`
            * :attr:`IdfwComputeCollectionCondition.STATUS_DOWN`
            * :attr:`IdfwComputeCollectionCondition.STATUS_DFW_DISABLED`
            * :attr:`IdfwComputeCollectionCondition.STATUS_IDFW_DISABLED`
            
             IDFW enabled Compute collection status.
        :type  status_detail: :class:`str` or ``None``
        :param status_detail: Status of the Compute collection.
        """
        self.status = status
        self.status_detail = status_detail
        VapiStruct.__init__(self)


IdfwComputeCollectionCondition._set_binding_type(type.StructType(
    'com.vmware.nsx.model.idfw_compute_collection_condition', {
        'status': type.OptionalType(type.StringType()),
        'status_detail': type.OptionalType(type.StringType()),
    },
    IdfwComputeCollectionCondition,
    False,
    None))



class IdfwComputeCollectionListResult(VapiStruct):
    """
    List of compute collection ids and status connected to VC.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`IdfwComputeCollectionStatus` or ``None``
        :param results: Array of IDFW compute collection Ids and status connected to VC.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


IdfwComputeCollectionListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.idfw_compute_collection_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IdfwComputeCollectionStatus'))),
    },
    IdfwComputeCollectionListResult,
    False,
    None))



class IdfwComputeCollectionStatus(VapiStruct):
    """
    compute collection ID and status connected to VC.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'compute_collection_id': 'compute_collection_id',
                            'compute_collection_status': 'compute_collection_status',
                            }

    def __init__(self,
                 compute_collection_id=None,
                 compute_collection_status=None,
                ):
        """
        :type  compute_collection_id: :class:`str` or ``None``
        :param compute_collection_id: IDFW compute collection ID connected to VC.
        :type  compute_collection_status: :class:`list` of :class:`IdfwComputeCollectionCondition` or ``None``
        :param compute_collection_status: IDFW enabled compute collection status.
        """
        self.compute_collection_id = compute_collection_id
        self.compute_collection_status = compute_collection_status
        VapiStruct.__init__(self)


IdfwComputeCollectionStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.idfw_compute_collection_status', {
        'compute_collection_id': type.OptionalType(type.StringType()),
        'compute_collection_status': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IdfwComputeCollectionCondition'))),
    },
    IdfwComputeCollectionStatus,
    False,
    None))



class IdfwDirGroupUserSessionMapping(VapiStruct):
    """
    Identity Firewall NSGorup to user mapping to link DirGroup to user session
    data.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'dir_group_id': 'dir_group_id',
                            'user_id': 'user_id',
                            }

    def __init__(self,
                 dir_group_id=None,
                 user_id=None,
                ):
        """
        :type  dir_group_id: :class:`str` or ``None``
        :param dir_group_id: Directory Group ID.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  user_id: :class:`str` or ``None``
        :param user_id: User ID.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.dir_group_id = dir_group_id
        self.user_id = user_id
        VapiStruct.__init__(self)


IdfwDirGroupUserSessionMapping._set_binding_type(type.StructType(
    'com.vmware.nsx.model.idfw_dir_group_user_session_mapping', {
        'dir_group_id': type.OptionalType(type.StringType()),
        'user_id': type.OptionalType(type.StringType()),
    },
    IdfwDirGroupUserSessionMapping,
    False,
    None))



class IdfwEnabledComputeCollection(VapiStruct):
    """
    Compute collection enabled for Identity Firewall where login events will be
    collected.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'compute_collection_id': 'compute_collection_id',
                            'compute_collection_name': 'compute_collection_name',
                            'enabled': 'enabled',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 compute_collection_id=None,
                 compute_collection_name=None,
                 enabled=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  compute_collection_id: :class:`str` or ``None``
        :param compute_collection_id: Compute collection ID.
        :type  compute_collection_name: :class:`str` or ``None``
        :param compute_collection_name: Compute collection name.
        :type  enabled: :class:`bool` or ``None``
        :param enabled: Compute collection enabled status (true=Enabled / false=Disabled).
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.compute_collection_id = compute_collection_id
        self.compute_collection_name = compute_collection_name
        self.enabled = enabled
        VapiStruct.__init__(self)


IdfwEnabledComputeCollection._set_binding_type(type.StructType(
    'com.vmware.nsx.model.idfw_enabled_compute_collection', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'compute_collection_id': type.OptionalType(type.StringType()),
        'compute_collection_name': type.OptionalType(type.StringType()),
        'enabled': type.OptionalType(type.BooleanType()),
    },
    IdfwEnabledComputeCollection,
    False,
    None))



class IdfwEnabledComputeCollectionListResult(VapiStruct):
    """
    List of compute collections enabled for IDFW where login events will be
    collected.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`IdfwEnabledComputeCollection` or ``None``
        :param results: Array of IDFW Enabled Compute Collections.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


IdfwEnabledComputeCollectionListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.idfw_enabled_compute_collection_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IdfwEnabledComputeCollection'))),
    },
    IdfwEnabledComputeCollectionListResult,
    False,
    None))



class IdfwMasterSwitchSetting(VapiStruct):
    """
    Identity Firewall master switch setting. This setting enables or disables
    Identity Firewall feature across the system. It affects compute
    collections, hypervisor and virtual machines. This operation is expensive
    and also has big impact and implication on system perforamce.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'idfw_master_switch_enabled': 'idfw_master_switch_enabled',
                            }

    def __init__(self,
                 idfw_master_switch_enabled=None,
                ):
        """
        :type  idfw_master_switch_enabled: :class:`bool` or ``None``
        :param idfw_master_switch_enabled: IDFW master switch (true=Enabled / false=Disabled).
        """
        self.idfw_master_switch_enabled = idfw_master_switch_enabled
        VapiStruct.__init__(self)


IdfwMasterSwitchSetting._set_binding_type(type.StructType(
    'com.vmware.nsx.model.idfw_master_switch_setting', {
        'idfw_master_switch_enabled': type.OptionalType(type.BooleanType()),
    },
    IdfwMasterSwitchSetting,
    False,
    None))



class IdfwNsgroupVmDetailListResult(VapiStruct):
    """
    Identity Firewall user login/session data for a single NSGroup.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'ns_group_id': 'ns_group_id',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 ns_group_id=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  ns_group_id: :class:`str` or ``None``
        :param ns_group_id: NSGroup ID
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`IdfwVmDetail` or ``None``
        :param results: List of user login/session data for a single VM
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.ns_group_id = ns_group_id
        self.results = results
        VapiStruct.__init__(self)


IdfwNsgroupVmDetailListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.idfw_nsgroup_vm_detail_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'ns_group_id': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IdfwVmDetail'))),
    },
    IdfwNsgroupVmDetailListResult,
    False,
    None))



class IdfwStandaloneHostsSwitchSetting(VapiStruct):
    """
    Identity Firewall standalone hosts switch setting. This setting enables or
    disables Identity Firewall feature on all standalone hosts.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'standalone_hosts_enabled': 'standalone_hosts_enabled',
                            }

    def __init__(self,
                 standalone_hosts_enabled=None,
                ):
        """
        :type  standalone_hosts_enabled: :class:`bool` or ``None``
        :param standalone_hosts_enabled: IDFW standalone hosts switch (true=Enabled / false=Disabled).
        """
        self.standalone_hosts_enabled = standalone_hosts_enabled
        VapiStruct.__init__(self)


IdfwStandaloneHostsSwitchSetting._set_binding_type(type.StructType(
    'com.vmware.nsx.model.idfw_standalone_hosts_switch_setting', {
        'standalone_hosts_enabled': type.OptionalType(type.BooleanType()),
    },
    IdfwStandaloneHostsSwitchSetting,
    False,
    None))



class IdfwSystemStats(VapiStruct):
    """
    Identity Firewall statistics data.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'num_concurrent_users': 'num_concurrent_users',
                            'num_user_sessions': 'num_user_sessions',
                            }

    def __init__(self,
                 num_concurrent_users=None,
                 num_user_sessions=None,
                ):
        """
        :type  num_concurrent_users: :class:`long` or ``None``
        :param num_concurrent_users: Number of concurrent logged on users (across VDI & RDSH). Multiple
            logins by the same user is counted as 1. format: int32
        :type  num_user_sessions: :class:`long` or ``None``
        :param num_user_sessions: Number of active user sessions/logins in IDFW enabled compute
            collections (including both UP and DOWN hosts). N sessions/logins
            by the same user is counted as n. format: int32
        """
        self.num_concurrent_users = num_concurrent_users
        self.num_user_sessions = num_user_sessions
        VapiStruct.__init__(self)


IdfwSystemStats._set_binding_type(type.StructType(
    'com.vmware.nsx.model.idfw_system_stats', {
        'num_concurrent_users': type.OptionalType(type.IntegerType()),
        'num_user_sessions': type.OptionalType(type.IntegerType()),
    },
    IdfwSystemStats,
    False,
    None))



class IdfwTransportNodeCondition(VapiStruct):
    """
    Status of the Identity Firewall Compute Collection's transport node.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATUS_UNKNOWN = "UNKNOWN"
    """


    """
    STATUS_UP = "UP"
    """


    """
    STATUS_DOWN = "DOWN"
    """


    """
    STATUS_NOT_PREPARED = "NOT_PREPARED"
    """


    """
    STATUS_IDFW_COMPONENT_NOT_INSTALLED = "IDFW_COMPONENT_NOT_INSTALLED"
    """


    """
    STATUS_DFW_DISABLED = "DFW_DISABLED"
    """


    """
    STATUS_IDFW_DISABLED = "IDFW_DISABLED"
    """


    """



    _canonical_to_pep_names = {
                            'status': 'status',
                            'status_detail': 'status_detail',
                            }

    def __init__(self,
                 status=None,
                 status_detail=None,
                ):
        """
        :type  status: :class:`str` or ``None``
        :param status: Possible values are: 
            
            * :attr:`IdfwTransportNodeCondition.STATUS_UNKNOWN`
            * :attr:`IdfwTransportNodeCondition.STATUS_UP`
            * :attr:`IdfwTransportNodeCondition.STATUS_DOWN`
            * :attr:`IdfwTransportNodeCondition.STATUS_NOT_PREPARED`
            *
              :attr:`IdfwTransportNodeCondition.STATUS_IDFW_COMPONENT_NOT_INSTALLED`
            * :attr:`IdfwTransportNodeCondition.STATUS_DFW_DISABLED`
            * :attr:`IdfwTransportNodeCondition.STATUS_IDFW_DISABLED`
            
             Transport node status for IDFW compute collection.
        :type  status_detail: :class:`str` or ``None``
        :param status_detail: IDFW Compute collection's transport node condition.
        """
        self.status = status
        self.status_detail = status_detail
        VapiStruct.__init__(self)


IdfwTransportNodeCondition._set_binding_type(type.StructType(
    'com.vmware.nsx.model.idfw_transport_node_condition', {
        'status': type.OptionalType(type.StringType()),
        'status_detail': type.OptionalType(type.StringType()),
    },
    IdfwTransportNodeCondition,
    False,
    None))



class IdfwTransportNodeStatus(VapiStruct):
    """
    ID and status of the Identity Firewall enabled Compute collection's
    transport node.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'transport_node_id': 'transport_node_id',
                            'transport_node_status': 'transport_node_status',
                            }

    def __init__(self,
                 transport_node_id=None,
                 transport_node_status=None,
                ):
        """
        :type  transport_node_id: :class:`str` or ``None``
        :param transport_node_id: TransportNode ID of the Identity Firewall enabled Compute
            collection's transport node.
        :type  transport_node_status: :class:`list` of :class:`IdfwTransportNodeCondition` or ``None``
        :param transport_node_status: Status of the IDFW transport node.
        """
        self.transport_node_id = transport_node_id
        self.transport_node_status = transport_node_status
        VapiStruct.__init__(self)


IdfwTransportNodeStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.idfw_transport_node_status', {
        'transport_node_id': type.OptionalType(type.StringType()),
        'transport_node_status': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IdfwTransportNodeCondition'))),
    },
    IdfwTransportNodeStatus,
    False,
    None))



class IdfwTransportNodeStatusListResult(VapiStruct):
    """
    Status of the Identity Firewall enabled Compute collection transport nodes.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`IdfwTransportNodeStatus` or ``None``
        :param results: List of transport node ids and status for idfw enabled Compute
            collection.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


IdfwTransportNodeStatusListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.idfw_transport_node_status_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IdfwTransportNodeStatus'))),
    },
    IdfwTransportNodeStatusListResult,
    False,
    None))



class IdfwUserSessionData(VapiStruct):
    """
    Identity Firewall user session data on a client machine (typically a VM).
    Multiple entries for the same user can be returned if the user logins to
    multiple sessions on the same VM.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'domain_name': 'domain_name',
                            'id': 'id',
                            'login_time': 'login_time',
                            'logout_time': 'logout_time',
                            'user_id': 'user_id',
                            'user_name': 'user_name',
                            'user_session_id': 'user_session_id',
                            'vm_ext_id': 'vm_ext_id',
                            }

    def __init__(self,
                 domain_name=None,
                 id=None,
                 login_time=None,
                 logout_time=None,
                 user_id=None,
                 user_name=None,
                 user_session_id=None,
                 vm_ext_id=None,
                ):
        """
        :type  domain_name: :class:`str` or ``None``
        :param domain_name: AD Domain of user.
        :type  id: :class:`str` or ``None``
        :param id: Identifier of user session data.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  login_time: :class:`long` or ``None``
        :param login_time: Login time. format: int64
        :type  logout_time: :class:`long` or ``None``
        :param logout_time: Logout time if applicable. An active user session has no logout
            time. Non-active user session is stored (up to last 5 most recent
            entries) per VM and per user. format: int64
        :type  user_id: :class:`str` or ``None``
        :param user_id: AD user ID (may not exist).
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  user_name: :class:`str` or ``None``
        :param user_name: AD user name.
        :type  user_session_id: :class:`long` or ``None``
        :param user_session_id: User session ID. This also indicates whether this is VDI / RDSH.
            format: int32
        :type  vm_ext_id: :class:`str` or ``None``
        :param vm_ext_id: Virtual machine (external ID or BIOS UUID) where login/logout
            events occurred.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.domain_name = domain_name
        self.id = id
        self.login_time = login_time
        self.logout_time = logout_time
        self.user_id = user_id
        self.user_name = user_name
        self.user_session_id = user_session_id
        self.vm_ext_id = vm_ext_id
        VapiStruct.__init__(self)


IdfwUserSessionData._set_binding_type(type.StructType(
    'com.vmware.nsx.model.idfw_user_session_data', {
        'domain_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'login_time': type.OptionalType(type.IntegerType()),
        'logout_time': type.OptionalType(type.IntegerType()),
        'user_id': type.OptionalType(type.StringType()),
        'user_name': type.OptionalType(type.StringType()),
        'user_session_id': type.OptionalType(type.IntegerType()),
        'vm_ext_id': type.OptionalType(type.StringType()),
    },
    IdfwUserSessionData,
    False,
    None))



class IdfwUserSessionDataAndMappings(VapiStruct):
    """
    Identity Firewall user session data list and Directory Group to user
    mappings.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'active_user_sessions': 'active_user_sessions',
                            'archived_user_sessions': 'archived_user_sessions',
                            'dir_group_to_user_session_data_mappings': 'dir_group_to_user_session_data_mappings',
                            }

    def __init__(self,
                 active_user_sessions=None,
                 archived_user_sessions=None,
                 dir_group_to_user_session_data_mappings=None,
                ):
        """
        :type  active_user_sessions: :class:`list` of :class:`IdfwUserSessionData` or ``None``
        :param active_user_sessions: Active user session data list
        :type  archived_user_sessions: :class:`list` of :class:`IdfwUserSessionData` or ``None``
        :param archived_user_sessions: Archived user session data list
        :type  dir_group_to_user_session_data_mappings: :class:`list` of :class:`IdfwDirGroupUserSessionMapping` or ``None``
        :param dir_group_to_user_session_data_mappings: Directory Group to user session data mappings
        """
        self.active_user_sessions = active_user_sessions
        self.archived_user_sessions = archived_user_sessions
        self.dir_group_to_user_session_data_mappings = dir_group_to_user_session_data_mappings
        VapiStruct.__init__(self)


IdfwUserSessionDataAndMappings._set_binding_type(type.StructType(
    'com.vmware.nsx.model.idfw_user_session_data_and_mappings', {
        'active_user_sessions': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IdfwUserSessionData'))),
        'archived_user_sessions': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IdfwUserSessionData'))),
        'dir_group_to_user_session_data_mappings': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IdfwDirGroupUserSessionMapping'))),
    },
    IdfwUserSessionDataAndMappings,
    False,
    None))



class IdfwUserStats(VapiStruct):
    """
    Identity Firewall user login/session data for a single user.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'active_sessions': 'active_sessions',
                            'archived_sessions': 'archived_sessions',
                            'user_id': 'user_id',
                            }

    def __init__(self,
                 active_sessions=None,
                 archived_sessions=None,
                 user_id=None,
                ):
        """
        :type  active_sessions: :class:`list` of :class:`IdfwUserSessionData` or ``None``
        :param active_sessions: List of active (still logged in) user login/sessions data (no
            limit)
        :type  archived_sessions: :class:`list` of :class:`IdfwUserSessionData` or ``None``
        :param archived_sessions: Optional list of up to 5 most recent archived (previously logged
            in) user login/session data.
        :type  user_id: :class:`str` or ``None``
        :param user_id: AD user Identifier (String ID)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.active_sessions = active_sessions
        self.archived_sessions = archived_sessions
        self.user_id = user_id
        VapiStruct.__init__(self)


IdfwUserStats._set_binding_type(type.StructType(
    'com.vmware.nsx.model.idfw_user_stats', {
        'active_sessions': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IdfwUserSessionData'))),
        'archived_sessions': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IdfwUserSessionData'))),
        'user_id': type.OptionalType(type.StringType()),
    },
    IdfwUserStats,
    False,
    None))



class IdfwVirtualMachineCondition(VapiStruct):
    """
    Status of the Identity Firewall compute collection's VM.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATUS_UNKNOWN = "UNKNOWN"
    """


    """
    STATUS_UP = "UP"
    """


    """
    STATUS_DOWN = "DOWN"
    """


    """
    STATUS_VM_TOOLS_NOT_INSTALLED = "VM_TOOLS_NOT_INSTALLED"
    """


    """
    STATUS_IDFW_NOT_SUPPORTED = "IDFW_NOT_SUPPORTED"
    """


    """
    STATUS_DFW_DISABLED = "DFW_DISABLED"
    """


    """
    STATUS_IDFW_DISABLED = "IDFW_DISABLED"
    """


    """



    _canonical_to_pep_names = {
                            'status': 'status',
                            'status_detail': 'status_detail',
                            }

    def __init__(self,
                 status=None,
                 status_detail=None,
                ):
        """
        :type  status: :class:`str` or ``None``
        :param status: Possible values are: 
            
            * :attr:`IdfwVirtualMachineCondition.STATUS_UNKNOWN`
            * :attr:`IdfwVirtualMachineCondition.STATUS_UP`
            * :attr:`IdfwVirtualMachineCondition.STATUS_DOWN`
            * :attr:`IdfwVirtualMachineCondition.STATUS_VM_TOOLS_NOT_INSTALLED`
            * :attr:`IdfwVirtualMachineCondition.STATUS_IDFW_NOT_SUPPORTED`
            * :attr:`IdfwVirtualMachineCondition.STATUS_DFW_DISABLED`
            * :attr:`IdfwVirtualMachineCondition.STATUS_IDFW_DISABLED`
            
             VM IDFW Status.
        :type  status_detail: :class:`str` or ``None``
        :param status_detail: IDFW compute collection's VM condition.
        """
        self.status = status
        self.status_detail = status_detail
        VapiStruct.__init__(self)


IdfwVirtualMachineCondition._set_binding_type(type.StructType(
    'com.vmware.nsx.model.idfw_virtual_machine_condition', {
        'status': type.OptionalType(type.StringType()),
        'status_detail': type.OptionalType(type.StringType()),
    },
    IdfwVirtualMachineCondition,
    False,
    None))



class IdfwVirtualMachineStatus(VapiStruct):
    """
    ID and status of the VM on Identity Firewall compute collection.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'vm_id': 'vm_id',
                            'vm_status': 'vm_status',
                            }

    def __init__(self,
                 vm_id=None,
                 vm_status=None,
                ):
        """
        :type  vm_id: :class:`str` or ``None``
        :param vm_id: VM ID of the VM on Identity Firewall compute collection.
        :type  vm_status: :class:`list` of :class:`IdfwVirtualMachineCondition` or ``None``
        :param vm_status: Status of the Identity Firewall compute collection's Virtual
            Machine.
        """
        self.vm_id = vm_id
        self.vm_status = vm_status
        VapiStruct.__init__(self)


IdfwVirtualMachineStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.idfw_virtual_machine_status', {
        'vm_id': type.OptionalType(type.StringType()),
        'vm_status': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IdfwVirtualMachineCondition'))),
    },
    IdfwVirtualMachineStatus,
    False,
    None))



class IdfwVirtualMachineStatusListResult(VapiStruct):
    """
    VM ID and status of the Identity Firewall Compute collection.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`IdfwVirtualMachineStatus` or ``None``
        :param results: List of VM's on Identity Firewall Compute collection.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


IdfwVirtualMachineStatusListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.idfw_virtual_machine_status_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IdfwVirtualMachineStatus'))),
    },
    IdfwVirtualMachineStatusListResult,
    False,
    None))



class IdfwVmDetail(VapiStruct):
    """
    Identity Firewall user login/session data for a single VM

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'last_login_user_session': 'last_login_user_session',
                            'user_sessions': 'user_sessions',
                            'vm_ext_id': 'vm_ext_id',
                            'vm_ip_addresses': 'vm_ip_addresses',
                            }

    def __init__(self,
                 last_login_user_session=None,
                 user_sessions=None,
                 vm_ext_id=None,
                 vm_ip_addresses=None,
                ):
        """
        :type  last_login_user_session: :class:`ResourceReference` or ``None``
        :param last_login_user_session: Record of the last logged in user session (if exists).
        :type  user_sessions: :class:`list` of :class:`IdfwUserSessionData` or ``None``
        :param user_sessions: List of user session data.
        :type  vm_ext_id: :class:`str` or ``None``
        :param vm_ext_id: Virtual machine (external ID or BIOS UUID) where login/logout event
            occurred.
        :type  vm_ip_addresses: :class:`list` of :class:`str` or ``None``
        :param vm_ip_addresses: List of client machine IP addresses.
        """
        self.last_login_user_session = last_login_user_session
        self.user_sessions = user_sessions
        self.vm_ext_id = vm_ext_id
        self.vm_ip_addresses = vm_ip_addresses
        VapiStruct.__init__(self)


IdfwVmDetail._set_binding_type(type.StructType(
    'com.vmware.nsx.model.idfw_vm_detail', {
        'last_login_user_session': type.OptionalType(type.ReferenceType(__name__, 'ResourceReference')),
        'user_sessions': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IdfwUserSessionData'))),
        'vm_ext_id': type.OptionalType(type.StringType()),
        'vm_ip_addresses': type.OptionalType(type.ListType(type.StringType())),
    },
    IdfwVmDetail,
    False,
    None))



class IdfwVmStats(VapiStruct):
    """
    Identity Firewall user login/session data for a single VM.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'active_sessions': 'active_sessions',
                            'archived_sessions': 'archived_sessions',
                            'vm_ext_id': 'vm_ext_id',
                            }

    def __init__(self,
                 active_sessions=None,
                 archived_sessions=None,
                 vm_ext_id=None,
                ):
        """
        :type  active_sessions: :class:`list` of :class:`IdfwUserSessionData` or ``None``
        :param active_sessions: List of active (still logged in) user login/sessions data (no
            limit)
        :type  archived_sessions: :class:`list` of :class:`IdfwUserSessionData` or ``None``
        :param archived_sessions: Optional list of up to 5 most recent archived (previously logged
            in) user login/session data.
        :type  vm_ext_id: :class:`str` or ``None``
        :param vm_ext_id: Virtual machine (external ID or BIOS UUID) where login/logout event
            occurred.
        """
        self.active_sessions = active_sessions
        self.archived_sessions = archived_sessions
        self.vm_ext_id = vm_ext_id
        VapiStruct.__init__(self)


IdfwVmStats._set_binding_type(type.StructType(
    'com.vmware.nsx.model.idfw_vm_stats', {
        'active_sessions': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IdfwUserSessionData'))),
        'archived_sessions': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IdfwUserSessionData'))),
        'vm_ext_id': type.OptionalType(type.StringType()),
    },
    IdfwVmStats,
    False,
    None))



class IdsEventFlowData(VapiStruct):
    """
    IDS event flow data specific to each IDS event. The data includes source
    ip, source port, destination ip, destination port, and protocol.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'client_ip': 'client_ip',
                            'destination_ip': 'destination_ip',
                            'destination_port': 'destination_port',
                            'local_vm_ip': 'local_vm_ip',
                            'protocol': 'protocol',
                            'source_ip': 'source_ip',
                            'source_port': 'source_port',
                            }

    def __init__(self,
                 client_ip=None,
                 destination_ip=None,
                 destination_port=None,
                 local_vm_ip=None,
                 protocol=None,
                 source_ip=None,
                 source_port=None,
                ):
        """
        :type  client_ip: :class:`str` or ``None``
        :param client_ip: IP address of the VM that initiated the communication.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  destination_ip: :class:`str` or ``None``
        :param destination_ip: IP address of the destination VM on the intrusion flow.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  destination_port: :class:`long` or ``None``
        :param destination_port: Port on the destination VM where the traffic was sent to. format:
            int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  local_vm_ip: :class:`str` or ``None``
        :param local_vm_ip: IP address of VM on the host where IDS engine is running.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protocol: :class:`str` or ``None``
        :param protocol: Traffic protocol pertaining to the detected intrusion, could be
            TCP/UDP etc.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  source_ip: :class:`str` or ``None``
        :param source_ip: IP address of the source VM on the intrusion flow.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  source_port: :class:`long` or ``None``
        :param source_port: Source port through which traffic was initiated that caused the
            intrusion to be detected. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.client_ip = client_ip
        self.destination_ip = destination_ip
        self.destination_port = destination_port
        self.local_vm_ip = local_vm_ip
        self.protocol = protocol
        self.source_ip = source_ip
        self.source_port = source_port
        VapiStruct.__init__(self)


IdsEventFlowData._set_binding_type(type.StructType(
    'com.vmware.nsx.model.ids_event_flow_data', {
        'client_ip': type.OptionalType(type.StringType()),
        'destination_ip': type.OptionalType(type.StringType()),
        'destination_port': type.OptionalType(type.IntegerType()),
        'local_vm_ip': type.OptionalType(type.StringType()),
        'protocol': type.OptionalType(type.StringType()),
        'source_ip': type.OptionalType(type.StringType()),
        'source_port': type.OptionalType(type.IntegerType()),
    },
    IdsEventFlowData,
    False,
    None))



class IdsGlobalConfig(VapiStruct):
    """
    NSX global configs for Distributed Intrusion Services

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "IdsGlobalConfig"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'global_idsevents_to_syslog_enabled': 'global_idsevents_to_syslog_enabled',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            }

    def __init__(self,
                 global_idsevents_to_syslog_enabled=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='IdsGlobalConfig',
                 tags=None,
                ):
        """
        :type  global_idsevents_to_syslog_enabled: :class:`bool` or ``None``
        :param global_idsevents_to_syslog_enabled: When this flag is set to true, IDS events would be sent to syslog.
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`GlobalConfigs.RESOURCE_TYPE_SWITCHINGGLOBALCONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_ROUTINGGLOBALCONFIG`
            *
              :attr:`GlobalConfigs.RESOURCE_TYPE_OPERATIONCOLLECTORGLOBALCONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_FIREWALLGLOBALCONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_ESXGLOBALOPAQUECONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_SECURITYGLOBALCONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_FIPSGLOBALCONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_FEDERATIONGLOBALCONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_IDSGLOBALCONFIG`
            
             Valid Global configuration types
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        """
        self.global_idsevents_to_syslog_enabled = global_idsevents_to_syslog_enabled
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

IdsGlobalConfig._set_binding_type(type.StructType(
    'com.vmware.nsx.model.ids_global_config', {
        'global_idsevents_to_syslog_enabled': type.OptionalType(type.BooleanType()),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
    },
    IdsGlobalConfig,
    False,
    None))



class IdsUserStats(VapiStruct):
    """
    List of Users logged into VMs where intrusions of a given signature were
    detected.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'count': 'count',
                            'user_list': 'user_list',
                            }

    def __init__(self,
                 count=None,
                 user_list=None,
                ):
        """
        :type  count: :class:`long` or ``None``
        :param count: Number of unique users logged into VMs on which a particular
            signature was detected. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  user_list: :class:`list` of :class:`str` or ``None``
        :param user_list: List of users logged into VMs on which a particular signature was
            detected.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.count = count
        self.user_list = user_list
        VapiStruct.__init__(self)


IdsUserStats._set_binding_type(type.StructType(
    'com.vmware.nsx.model.ids_user_stats', {
        'count': type.OptionalType(type.IntegerType()),
        'user_list': type.OptionalType(type.ListType(type.StringType())),
    },
    IdsUserStats,
    False,
    None))



class IdsVmList(VapiStruct):
    """
    List of all affected VMs pertaining to a specific signature.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`str` or ``None``
        :param results: List of all affected VMs specific to a particular signature.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


IdsVmList._set_binding_type(type.StructType(
    'com.vmware.nsx.model.ids_vm_list', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.StringType())),
    },
    IdsVmList,
    False,
    None))



class IdsVmStats(VapiStruct):
    """
    List of VMs on which a particular signature was detected with the count.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'count': 'count',
                            'vm_list': 'vm_list',
                            }

    def __init__(self,
                 count=None,
                 vm_list=None,
                ):
        """
        :type  count: :class:`long` or ``None``
        :param count: Number of unique VMs on which a particular signature was detected.
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  vm_list: :class:`list` of :class:`str` or ``None``
        :param vm_list: List of VM names on which intrusions of that particular signature
            type were detected.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.count = count
        self.vm_list = vm_list
        VapiStruct.__init__(self)


IdsVmStats._set_binding_type(type.StructType(
    'com.vmware.nsx.model.ids_vm_stats', {
        'count': type.OptionalType(type.IntegerType()),
        'vm_list': type.OptionalType(type.ListType(type.StringType())),
    },
    IdsVmStats,
    False,
    None))



class IncludedFieldsParameters(VapiStruct):
    """
    A list of fields to include in query results

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'included_fields': 'included_fields',
                            }

    def __init__(self,
                 included_fields=None,
                ):
        """
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result
        """
        self.included_fields = included_fields
        VapiStruct.__init__(self)


IncludedFieldsParameters._set_binding_type(type.StructType(
    'com.vmware.nsx.model.included_fields_parameters', {
        'included_fields': type.OptionalType(type.StringType()),
    },
    IncludedFieldsParameters,
    False,
    None))



class IngressBroadcastRateShaper(VapiStruct):
    """
    A shaper that specifies ingress rate properties in kb/s

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "IngressBroadcastRateShaper"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'average_bandwidth_kbps': 'average_bandwidth_kbps',
                            'burst_size_bytes': 'burst_size_bytes',
                            'peak_bandwidth_kbps': 'peak_bandwidth_kbps',
                            'enabled': 'enabled',
                            'resource_type': 'resource_type',
                            }

    def __init__(self,
                 average_bandwidth_kbps=None,
                 burst_size_bytes=None,
                 peak_bandwidth_kbps=None,
                 enabled=None,
                 resource_type='IngressBroadcastRateShaper',
                ):
        """
        :type  average_bandwidth_kbps: :class:`long` or ``None``
        :param average_bandwidth_kbps: Average bandwidth in kb/s format: int32
        :type  burst_size_bytes: :class:`long` or ``None``
        :param burst_size_bytes: Burst size in bytes format: int32
        :type  peak_bandwidth_kbps: :class:`long` or ``None``
        :param peak_bandwidth_kbps: Peak bandwidth in kb/s format: int32
        :type  enabled: :class:`bool` or ``None``
        :param enabled: 
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`QosBaseRateShaper.RESOURCE_TYPE_INGRESSRATESHAPER`
            *
              :attr:`QosBaseRateShaper.RESOURCE_TYPE_INGRESSBROADCASTRATESHAPER`
            * :attr:`QosBaseRateShaper.RESOURCE_TYPE_EGRESSRATESHAPER`
        """
        self.average_bandwidth_kbps = average_bandwidth_kbps
        self.burst_size_bytes = burst_size_bytes
        self.peak_bandwidth_kbps = peak_bandwidth_kbps
        self.enabled = enabled
        self._resource_type = resource_type
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

IngressBroadcastRateShaper._set_binding_type(type.StructType(
    'com.vmware.nsx.model.ingress_broadcast_rate_shaper', {
        'average_bandwidth_kbps': type.OptionalType(type.IntegerType()),
        'burst_size_bytes': type.OptionalType(type.IntegerType()),
        'peak_bandwidth_kbps': type.OptionalType(type.IntegerType()),
        'enabled': type.OptionalType(type.BooleanType()),
        'resource_type': type.StringType(),
    },
    IngressBroadcastRateShaper,
    False,
    None))



class IngressRateShaper(VapiStruct):
    """
    A shaper that specifies ingress rate properties in Mb/s

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "IngressRateShaper"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'average_bandwidth_mbps': 'average_bandwidth_mbps',
                            'burst_size_bytes': 'burst_size_bytes',
                            'peak_bandwidth_mbps': 'peak_bandwidth_mbps',
                            'enabled': 'enabled',
                            'resource_type': 'resource_type',
                            }

    def __init__(self,
                 average_bandwidth_mbps=None,
                 burst_size_bytes=None,
                 peak_bandwidth_mbps=None,
                 enabled=None,
                 resource_type='IngressRateShaper',
                ):
        """
        :type  average_bandwidth_mbps: :class:`long` or ``None``
        :param average_bandwidth_mbps: Average bandwidth in Mb/s format: int32
        :type  burst_size_bytes: :class:`long` or ``None``
        :param burst_size_bytes: Burst size in bytes format: int32
        :type  peak_bandwidth_mbps: :class:`long` or ``None``
        :param peak_bandwidth_mbps: Peak bandwidth in Mb/s format: int32
        :type  enabled: :class:`bool` or ``None``
        :param enabled: 
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`QosBaseRateShaper.RESOURCE_TYPE_INGRESSRATESHAPER`
            *
              :attr:`QosBaseRateShaper.RESOURCE_TYPE_INGRESSBROADCASTRATESHAPER`
            * :attr:`QosBaseRateShaper.RESOURCE_TYPE_EGRESSRATESHAPER`
        """
        self.average_bandwidth_mbps = average_bandwidth_mbps
        self.burst_size_bytes = burst_size_bytes
        self.peak_bandwidth_mbps = peak_bandwidth_mbps
        self.enabled = enabled
        self._resource_type = resource_type
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

IngressRateShaper._set_binding_type(type.StructType(
    'com.vmware.nsx.model.ingress_rate_shaper', {
        'average_bandwidth_mbps': type.OptionalType(type.IntegerType()),
        'burst_size_bytes': type.OptionalType(type.IntegerType()),
        'peak_bandwidth_mbps': type.OptionalType(type.IntegerType()),
        'enabled': type.OptionalType(type.BooleanType()),
        'resource_type': type.StringType(),
    },
    IngressRateShaper,
    False,
    None))



class InitiateClusterRestoreRequest(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'ip_address': 'ip_address',
                            'node_id': 'node_id',
                            'timestamp': 'timestamp',
                            }

    def __init__(self,
                 ip_address=None,
                 node_id=None,
                 timestamp=None,
                ):
        """
        :type  ip_address: :class:`str` or ``None``
        :param ip_address: IP address or FQDN of the node from which the backup was taken
            format: hostname-or-ip
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  node_id: :class:`str` or ``None``
        :param node_id: Unique id of the backed-up configuration from which the appliance
            will be restored
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  timestamp: :class:`long` or ``None``
        :param timestamp: Timestamp of the backed-up configuration from which the appliance
            will be restored format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.ip_address = ip_address
        self.node_id = node_id
        self.timestamp = timestamp
        VapiStruct.__init__(self)


InitiateClusterRestoreRequest._set_binding_type(type.StructType(
    'com.vmware.nsx.model.initiate_cluster_restore_request', {
        'ip_address': type.OptionalType(type.StringType()),
        'node_id': type.OptionalType(type.StringType()),
        'timestamp': type.OptionalType(type.IntegerType()),
    },
    InitiateClusterRestoreRequest,
    False,
    None))



class InstallUpgradeServiceProperties(VapiStruct):
    """
    install-upgrade service properties

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'enabled': 'enabled',
                            'enabled_on': 'enabled_on',
                            }

    def __init__(self,
                 enabled=None,
                 enabled_on=None,
                ):
        """
        :type  enabled: :class:`bool` or ``None``
        :param enabled: True if service enabled; otherwise, false
        :type  enabled_on: :class:`str` or ``None``
        :param enabled_on: IP of manager on which install-upgrade is enabled
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.enabled = enabled
        self.enabled_on = enabled_on
        VapiStruct.__init__(self)


InstallUpgradeServiceProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.install_upgrade_service_properties', {
        'enabled': type.OptionalType(type.BooleanType()),
        'enabled_on': type.OptionalType(type.StringType()),
    },
    InstallUpgradeServiceProperties,
    False,
    None))



class InstanceDeploymentConfig(VapiStruct):
    """
    The Instance Deployment Config contains settings that is applied during
    install time.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'compute_id': 'compute_id',
                            'context_id': 'context_id',
                            'host_id': 'host_id',
                            'storage_id': 'storage_id',
                            'vm_nic_infos': 'vm_nic_infos',
                            }

    def __init__(self,
                 compute_id=None,
                 context_id=None,
                 host_id=None,
                 storage_id=None,
                 vm_nic_infos=None,
                ):
        """
        :type  compute_id: :class:`str` or ``None``
        :param compute_id: Resource Pool or Compute Id.
        :type  context_id: :class:`str` or ``None``
        :param context_id: Context Id or VCenter Id.
        :type  host_id: :class:`str` or ``None``
        :param host_id: The service VM will be deployed on the specified host in the
            specified server within the cluster if host_id is specified. Note:
            You must ensure that storage and specified networks are accessible
            by this host.
        :type  storage_id: :class:`str` or ``None``
        :param storage_id: Storage Id.
        :type  vm_nic_infos: :class:`list` of :class:`VmNicInfo` or ``None``
        :param vm_nic_infos: List of NIC information for VMs
        """
        self.compute_id = compute_id
        self.context_id = context_id
        self.host_id = host_id
        self.storage_id = storage_id
        self.vm_nic_infos = vm_nic_infos
        VapiStruct.__init__(self)


InstanceDeploymentConfig._set_binding_type(type.StructType(
    'com.vmware.nsx.model.instance_deployment_config', {
        'compute_id': type.OptionalType(type.StringType()),
        'context_id': type.OptionalType(type.StringType()),
        'host_id': type.OptionalType(type.StringType()),
        'storage_id': type.OptionalType(type.StringType()),
        'vm_nic_infos': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'VmNicInfo'))),
    },
    InstanceDeploymentConfig,
    False,
    None))



class InstanceEndpoint(VapiStruct):
    """
    An InstanceEndpoint belongs to one ServiceInstance and represents a
    redirection target for a Rule. For Example - It can be an L3 Destination.
    Service Attachments is required for a InstanceEndpoint of type LOGICAL, and
    deployed_to if its a VIRTUAL InstanceEndpoint.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    ENDPOINT_TYPE_LOGICAL = "LOGICAL"
    """


    """
    ENDPOINT_TYPE_VIRTUAL = "VIRTUAL"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'endpoint_type': 'endpoint_type',
                            'link_ids': 'link_ids',
                            'service_attachments': 'service_attachments',
                            'service_instance_id': 'service_instance_id',
                            'target_ips': 'target_ips',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 endpoint_type=None,
                 link_ids=None,
                 service_attachments=None,
                 service_instance_id=None,
                 target_ips=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  endpoint_type: :class:`str` or ``None``
        :param endpoint_type: Possible values are: 
            
            * :attr:`InstanceEndpoint.ENDPOINT_TYPE_LOGICAL`
            * :attr:`InstanceEndpoint.ENDPOINT_TYPE_VIRTUAL`
            
            LOGICAL - It must be created with a ServiceAttachment and
            identifies a destination connected to the Service Port of the
            ServiceAttachment, through the ServiceAttachment's Logical Switch.
            VIRTUAL - It represents a L3 destination the router can route to
            but does not provide any further information about its location in
            the network. Virtual InstanceEndpoints are used for redirection
            targets that are not connected to Service Ports, such as the
            next-hop routers on the Edge uplinks.
        :type  link_ids: :class:`list` of :class:`ResourceReference` or ``None``
        :param link_ids: Link Ids are mandatory for VIRTUAL Instance Endpoint. Even though
            VIRTUAL, the Instance Endpoint should be connected/accessible
            through an NSX object. The link id is this NSX object id. Example -
            For North-South Service Insertion, this is the LogicalRouter Id
            through which the targetIp/L3 destination accessible.
        :type  service_attachments: :class:`list` of :class:`ResourceReference` or ``None``
        :param service_attachments: Id(s) of the Service Attachment where this enndpoint is connected
            to. Service Attachment is mandatory for LOGICAL Instance Endpoint.
        :type  service_instance_id: :class:`str` or ``None``
        :param service_instance_id: The Service instancee with which the instance endpoint is
            associated.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  target_ips: :class:`list` of :class:`IPInfo` or ``None``
        :param target_ips: Target IPs on an interface of the Service Instance.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.endpoint_type = endpoint_type
        self.link_ids = link_ids
        self.service_attachments = service_attachments
        self.service_instance_id = service_instance_id
        self.target_ips = target_ips
        VapiStruct.__init__(self)


InstanceEndpoint._set_binding_type(type.StructType(
    'com.vmware.nsx.model.instance_endpoint', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'endpoint_type': type.OptionalType(type.StringType()),
        'link_ids': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceReference'))),
        'service_attachments': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceReference'))),
        'service_instance_id': type.OptionalType(type.StringType()),
        'target_ips': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IPInfo'))),
    },
    InstanceEndpoint,
    False,
    None))



class InstanceEndpointListResult(VapiStruct):
    """
    List of instance endpoints.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`InstanceEndpoint` or ``None``
        :param results: List of instance endpoints.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


InstanceEndpointListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.instance_endpoint_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'InstanceEndpoint'))),
    },
    InstanceEndpointListResult,
    False,
    None))



class InstanceRuntime(VapiStruct):
    """
    A Service Runtime is the runtime entity associated with ever Service-VM
    deployed.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    DEPLOYMENT_STATUS_DEPLOYMENT_IN_PROGRESS = "DEPLOYMENT_IN_PROGRESS"
    """


    """
    DEPLOYMENT_STATUS_DEPLOYMENT_FAILED = "DEPLOYMENT_FAILED"
    """


    """
    DEPLOYMENT_STATUS_DEPLOYMENT_SUCCESSFUL = "DEPLOYMENT_SUCCESSFUL"
    """


    """
    DEPLOYMENT_STATUS_UPGRADE_IN_PROGRESS = "UPGRADE_IN_PROGRESS"
    """


    """
    DEPLOYMENT_STATUS_UPGRADE_FAILED = "UPGRADE_FAILED"
    """


    """
    DEPLOYMENT_STATUS_UNDEPLOYMENT_IN_PROGRESS = "UNDEPLOYMENT_IN_PROGRESS"
    """


    """
    DEPLOYMENT_STATUS_UNDEPLOYMENT_FAILED = "UNDEPLOYMENT_FAILED"
    """


    """
    DEPLOYMENT_STATUS_UNDEPLOYMENT_SUCCESSFUL = "UNDEPLOYMENT_SUCCESSFUL"
    """


    """
    DEPLOYMENT_STATUS_UNKNOWN = "UNKNOWN"
    """


    """
    MAINTENANCE_MODE_OFF = "OFF"
    """


    """
    MAINTENANCE_MODE_ENTERING = "ENTERING"
    """


    """
    MAINTENANCE_MODE_ON = "ON"
    """


    """
    MAINTENANCE_MODE_EXITING = "EXITING"
    """


    """
    RUNTIME_HEALTH_STATUS_BY_PARTNER_HEALTHY = "HEALTHY"
    """


    """
    RUNTIME_HEALTH_STATUS_BY_PARTNER_STOPPED = "STOPPED"
    """


    """
    RUNTIME_HEALTH_STATUS_BY_PARTNER_NOT_RESPONDING = "NOT_RESPONDING"
    """


    """
    RUNTIME_STATUS_IN_SERVICE = "IN_SERVICE"
    """


    """
    RUNTIME_STATUS_OUT_OF_SERVICE = "OUT_OF_SERVICE"
    """


    """
    RUNTIME_STATUS_NEEDS_ATTENTION = "NEEDS_ATTENTION"
    """


    """
    RUNTIME_STATUS_NOT_AVAILABLE = "NOT_AVAILABLE"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'deployment_status': 'deployment_status',
                            'error_message': 'error_message',
                            'maintenance_mode': 'maintenance_mode',
                            'runtime_health_status_by_partner': 'runtime_health_status_by_partner',
                            'runtime_status': 'runtime_status',
                            'service_instance_id': 'service_instance_id',
                            'service_vm_id': 'service_vm_id',
                            'unhealthy_reason': 'unhealthy_reason',
                            'vm_nic_info': 'vm_nic_info',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 deployment_status=None,
                 error_message=None,
                 maintenance_mode=None,
                 runtime_health_status_by_partner=None,
                 runtime_status=None,
                 service_instance_id=None,
                 service_vm_id=None,
                 unhealthy_reason=None,
                 vm_nic_info=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  deployment_status: :class:`str` or ``None``
        :param deployment_status: Possible values are: 
            
            * :attr:`InstanceRuntime.DEPLOYMENT_STATUS_DEPLOYMENT_IN_PROGRESS`
            * :attr:`InstanceRuntime.DEPLOYMENT_STATUS_DEPLOYMENT_FAILED`
            * :attr:`InstanceRuntime.DEPLOYMENT_STATUS_DEPLOYMENT_SUCCESSFUL`
            * :attr:`InstanceRuntime.DEPLOYMENT_STATUS_UPGRADE_IN_PROGRESS`
            * :attr:`InstanceRuntime.DEPLOYMENT_STATUS_UPGRADE_FAILED`
            *
              :attr:`InstanceRuntime.DEPLOYMENT_STATUS_UNDEPLOYMENT_IN_PROGRESS`
            * :attr:`InstanceRuntime.DEPLOYMENT_STATUS_UNDEPLOYMENT_FAILED`
            * :attr:`InstanceRuntime.DEPLOYMENT_STATUS_UNDEPLOYMENT_SUCCESSFUL`
            * :attr:`InstanceRuntime.DEPLOYMENT_STATUS_UNKNOWN`
            
            Service-Instance Runtime deployment status of the Service-VM. It
            shows the latest status during the process of deployment, redeploy,
            upgrade, and un-deployment of VM.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  error_message: :class:`str` or ``None``
        :param error_message: Error message for the Service Instance Runtime if any.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  maintenance_mode: :class:`str` or ``None``
        :param maintenance_mode: Possible values are: 
            
            * :attr:`InstanceRuntime.MAINTENANCE_MODE_OFF`
            * :attr:`InstanceRuntime.MAINTENANCE_MODE_ENTERING`
            * :attr:`InstanceRuntime.MAINTENANCE_MODE_ON`
            * :attr:`InstanceRuntime.MAINTENANCE_MODE_EXITING`
            
            The maintenance mode indicates whether the corresponding service VM
            is in maintenance mode. The service VM will not be used to service
            new requests if it is in maintenance mode.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  runtime_health_status_by_partner: :class:`str` or ``None``
        :param runtime_health_status_by_partner: Possible values are: 
            
            * :attr:`InstanceRuntime.RUNTIME_HEALTH_STATUS_BY_PARTNER_HEALTHY`
            * :attr:`InstanceRuntime.RUNTIME_HEALTH_STATUS_BY_PARTNER_STOPPED`
            *
              :attr:`InstanceRuntime.RUNTIME_HEALTH_STATUS_BY_PARTNER_NOT_RESPONDING`
            
            Service-Instance runtime health status set by partner to indicate
            whether the service is running properly or not.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  runtime_status: :class:`str` or ``None``
        :param runtime_status: Possible values are: 
            
            * :attr:`InstanceRuntime.RUNTIME_STATUS_IN_SERVICE`
            * :attr:`InstanceRuntime.RUNTIME_STATUS_OUT_OF_SERVICE`
            * :attr:`InstanceRuntime.RUNTIME_STATUS_NEEDS_ATTENTION`
            * :attr:`InstanceRuntime.RUNTIME_STATUS_NOT_AVAILABLE`
            
             Service-Instance Runtime status of the deployed Service-VM.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  service_instance_id: :class:`str` or ``None``
        :param service_instance_id: Id of an instantiation of a registered service.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  service_vm_id: :class:`str` or ``None``
        :param service_vm_id: Service-VM/SVM id of deployed virtual-machine.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  unhealthy_reason: :class:`str` or ``None``
        :param unhealthy_reason: Reason provided by partner for the service being unhealthy. This
            could be due to various reasons such as connectivity lost as an
            example.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  vm_nic_info: :class:`VmNicInfo` or ``None``
        :param vm_nic_info: VM NIC info
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.deployment_status = deployment_status
        self.error_message = error_message
        self.maintenance_mode = maintenance_mode
        self.runtime_health_status_by_partner = runtime_health_status_by_partner
        self.runtime_status = runtime_status
        self.service_instance_id = service_instance_id
        self.service_vm_id = service_vm_id
        self.unhealthy_reason = unhealthy_reason
        self.vm_nic_info = vm_nic_info
        VapiStruct.__init__(self)


InstanceRuntime._set_binding_type(type.StructType(
    'com.vmware.nsx.model.instance_runtime', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'deployment_status': type.OptionalType(type.StringType()),
        'error_message': type.OptionalType(type.StringType()),
        'maintenance_mode': type.OptionalType(type.StringType()),
        'runtime_health_status_by_partner': type.OptionalType(type.StringType()),
        'runtime_status': type.OptionalType(type.StringType()),
        'service_instance_id': type.OptionalType(type.StringType()),
        'service_vm_id': type.OptionalType(type.StringType()),
        'unhealthy_reason': type.OptionalType(type.StringType()),
        'vm_nic_info': type.OptionalType(type.ReferenceType(__name__, 'VmNicInfo')),
    },
    InstanceRuntime,
    False,
    None))



class InstanceRuntimeListResult(VapiStruct):
    """
    Result of List of InstanceRuntimes

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`InstanceRuntime` or ``None``
        :param results: Array of existing InstanceRuntimes in database
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


InstanceRuntimeListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.instance_runtime_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'InstanceRuntime'))),
    },
    InstanceRuntimeListResult,
    False,
    None))



class InstructionInfo(VapiStruct):
    """
    Details of the instructions displayed during restore process

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'actions': 'actions',
                            'fields': 'fields',
                            'id': 'id',
                            'name': 'name',
                            }

    def __init__(self,
                 actions=None,
                 fields=None,
                 id=None,
                 name=None,
                ):
        """
        :type  actions: :class:`list` of :class:`str` or ``None``
        :param actions: A list of actions that are to be applied to resources
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  fields: :class:`list` of :class:`str` or ``None``
        :param fields: A list of fields that are displayable to users in a table
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  id: :class:`str` or ``None``
        :param id: UUID of the instruction
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  name: :class:`str` or ``None``
        :param name: Instruction name
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.actions = actions
        self.fields = fields
        self.id = id
        self.name = name
        VapiStruct.__init__(self)


InstructionInfo._set_binding_type(type.StructType(
    'com.vmware.nsx.model.instruction_info', {
        'actions': type.OptionalType(type.ListType(type.StringType())),
        'fields': type.OptionalType(type.ListType(type.StringType())),
        'id': type.OptionalType(type.StringType()),
        'name': type.OptionalType(type.StringType()),
    },
    InstructionInfo,
    False,
    None))



class IntelligenceBrokerEndpointInfo(VapiStruct):
    """
    An endpoint to connect to NSX-Intelligence broker. Either FQDN or IP
    address can be used in the endpoint info.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'address': 'address',
                            'port': 'port',
                            }

    def __init__(self,
                 address=None,
                 port=None,
                ):
        """
        :type  address: :class:`str` or ``None``
        :param address: The IP address or the full qualified domain name of broker. format:
            ip-or-hostname
        :type  port: :class:`long` or ``None``
        :param port: The port number where the broker is listening to. format: int64
        """
        self.address = address
        self.port = port
        VapiStruct.__init__(self)


IntelligenceBrokerEndpointInfo._set_binding_type(type.StructType(
    'com.vmware.nsx.model.intelligence_broker_endpoint_info', {
        'address': type.OptionalType(type.StringType()),
        'port': type.OptionalType(type.IntegerType()),
    },
    IntelligenceBrokerEndpointInfo,
    False,
    None))



class IntelligenceClusterNodeVMDeploymentConfig(VapiStruct):
    """
    Contains info used to configure the VM on deployment

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "IntelligenceClusterNodeVMDeploymentConfig"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    PLACEMENT_TYPE_INTELLIGENCEVSPHERECLUSTERNODEVMDEPLOYMENTCONFIG = "IntelligenceVsphereClusterNodeVMDeploymentConfig"
    """


    """



    _canonical_to_pep_names = {
                            'placement_type': 'placement_type',
                            }

    def __init__(self,
                 placement_type='IntelligenceClusterNodeVMDeploymentConfig',
                ):
        """
        :type  placement_type: :class:`str`
        :param placement_type: Possible values are: 
            
            *
              :attr:`IntelligenceClusterNodeVMDeploymentConfig.PLACEMENT_TYPE_INTELLIGENCEVSPHERECLUSTERNODEVMDEPLOYMENTCONFIG`
            
            Specifies the config for the platform through which to deploy the
            VM
        """
        self._placement_type = placement_type
        VapiStruct.__init__(self)

    @property
    def placement_type(self):
        """
        Return the discriminator value
        """
        return self._placement_type

IntelligenceClusterNodeVMDeploymentConfig._set_binding_type(type.StructType(
    'com.vmware.nsx.model.intelligence_cluster_node_VM_deployment_config', {
        'placement_type': type.StringType(),
    },
    IntelligenceClusterNodeVMDeploymentConfig,
    False,
    None))



class IntelligenceClusterNodeVMDeploymentRequest(VapiStruct):
    """
    Contains the deployment information for a NSX-Intelligence node VM.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    FORM_FACTOR_SMALL = "SMALL"
    """


    """
    FORM_FACTOR_LARGE = "LARGE"
    """


    """
    FORM_FACTOR_EXTRA_LARGE = "EXTRA_LARGE"
    """


    """



    _canonical_to_pep_names = {
                            'deployment_config': 'deployment_config',
                            'form_factor': 'form_factor',
                            'user_settings': 'user_settings',
                            'vm_id': 'vm_id',
                            }

    def __init__(self,
                 deployment_config=None,
                 form_factor=None,
                 user_settings=None,
                 vm_id=None,
                ):
        """
        :type  deployment_config: :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param deployment_config: Info needed to configure a NSX-Intelligence cluster node VM at
            deployment for a specific platform.
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`IntelligenceClusterNodeVMDeploymentConfig`. When methods
            return a value of this class as a return value, the attribute will
            contain all the attributes defined in
            :class:`IntelligenceClusterNodeVMDeploymentConfig`.
        :type  form_factor: :class:`str` or ``None``
        :param form_factor: Possible values are: 
            
            *
              :attr:`IntelligenceClusterNodeVMDeploymentRequest.FORM_FACTOR_SMALL`
            *
              :attr:`IntelligenceClusterNodeVMDeploymentRequest.FORM_FACTOR_LARGE`
            *
              :attr:`IntelligenceClusterNodeVMDeploymentRequest.FORM_FACTOR_EXTRA_LARGE`
            
             Specifies the desired \"size\" of the VM
        :type  user_settings: :class:`NodeUserSettings` or ``None``
        :param user_settings: Username and password settings for the NSX-Intelligence node VM.
            Passwords must be at least 12 characters in length and contain at
            least one lowercase, one uppercase, one numerical, and one special
            character. Note: These settings will be honored only during VM
            deployment. Post-deployment, CLI must be used for changing the user
            settings and changes to these parameters will not have any effect.
        :type  vm_id: :class:`str` or ``None``
        :param vm_id: ID of the VM maintained internally. Note: This is automatically
            generated and cannot be modified.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.deployment_config = deployment_config
        self.form_factor = form_factor
        self.user_settings = user_settings
        self.vm_id = vm_id
        VapiStruct.__init__(self)


IntelligenceClusterNodeVMDeploymentRequest._set_binding_type(type.StructType(
    'com.vmware.nsx.model.intelligence_cluster_node_VM_deployment_request', {
        'deployment_config': type.OptionalType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'IntelligenceClusterNodeVMDeploymentConfig')])),
        'form_factor': type.OptionalType(type.StringType()),
        'user_settings': type.OptionalType(type.ReferenceType(__name__, 'NodeUserSettings')),
        'vm_id': type.OptionalType(type.StringType()),
    },
    IntelligenceClusterNodeVMDeploymentRequest,
    False,
    None))



class IntelligenceClusterNodeVMDeploymentRequestList(VapiStruct):
    """
    List of IntelligenceClusterNodeVMDeploymentRequests

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`IntelligenceClusterNodeVMDeploymentRequest` or ``None``
        :param results: Array of existing IntelligenceClusterNodeVMDeploymentRequests
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


IntelligenceClusterNodeVMDeploymentRequestList._set_binding_type(type.StructType(
    'com.vmware.nsx.model.intelligence_cluster_node_VM_deployment_request_list', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IntelligenceClusterNodeVMDeploymentRequest'))),
    },
    IntelligenceClusterNodeVMDeploymentRequestList,
    False,
    None))



class IntelligenceClusterNodeVMDeploymentStatusReport(VapiStruct):
    """
    Contains up-to-date information relating to an auto-deployed VM, including
    its status and (potentially) an error message.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATUS_NOT_AVAILABLE = "NOT_AVAILABLE"
    """


    """
    STATUS_VM_DEPLOYMENT_QUEUED = "VM_DEPLOYMENT_QUEUED"
    """


    """
    STATUS_VM_DEPLOYMENT_IN_PROGRESS = "VM_DEPLOYMENT_IN_PROGRESS"
    """


    """
    STATUS_VM_DEPLOYMENT_FAILED = "VM_DEPLOYMENT_FAILED"
    """


    """
    STATUS_VM_POWER_ON_IN_PROGRESS = "VM_POWER_ON_IN_PROGRESS"
    """


    """
    STATUS_VM_POWER_ON_FAILED = "VM_POWER_ON_FAILED"
    """


    """
    STATUS_VM_POWER_ON_SUCCESSFUL = "VM_POWER_ON_SUCCESSFUL"
    """


    """
    STATUS_VM_REGISTRATION_IN_PROGRESS = "VM_REGISTRATION_IN_PROGRESS"
    """


    """
    STATUS_VM_REGISTRATION_SUCCESSFUL = "VM_REGISTRATION_SUCCESSFUL"
    """


    """
    STATUS_VM_REGISTRATION_FAILED = "VM_REGISTRATION_FAILED"
    """


    """
    STATUS_VM_WAITING_TO_COME_ONLINE = "VM_WAITING_TO_COME_ONLINE"
    """


    """
    STATUS_VM_ONLINE_FAILED = "VM_ONLINE_FAILED"
    """


    """
    STATUS_VM_POWER_OFF_IN_PROGRESS = "VM_POWER_OFF_IN_PROGRESS"
    """


    """
    STATUS_VM_POWER_OFF_FAILED = "VM_POWER_OFF_FAILED"
    """


    """
    STATUS_WAITING_TO_UNDEPLOY_VM = "WAITING_TO_UNDEPLOY_VM"
    """


    """
    STATUS_VM_UNDEPLOY_IN_PROGRESS = "VM_UNDEPLOY_IN_PROGRESS"
    """


    """
    STATUS_VM_UNDEPLOY_FAILED = "VM_UNDEPLOY_FAILED"
    """


    """
    STATUS_VM_UNDEPLOY_SUCCESSFUL = "VM_UNDEPLOY_SUCCESSFUL"
    """


    """
    STATUS_UNKNOWN_STATE = "UNKNOWN_STATE"
    """


    """



    _canonical_to_pep_names = {
                            'deployment_progress_state': 'deployment_progress_state',
                            'failure_code': 'failure_code',
                            'failure_message': 'failure_message',
                            'status': 'status',
                            }

    def __init__(self,
                 deployment_progress_state=None,
                 failure_code=None,
                 failure_message=None,
                 status=None,
                ):
        """
        :type  deployment_progress_state: :class:`ClusterNodeVMDeploymentProgressState` or ``None``
        :param deployment_progress_state: Detailed progress state of node VM deployment realization
        :type  failure_code: :class:`long` or ``None``
        :param failure_code: In case of auto-deployment-related failure, the code for the error
            will be stored here. format: int64
        :type  failure_message: :class:`str` or ``None``
        :param failure_message: In case of auto-deployment-related failure, an error message will
            be stored here.
        :type  status: :class:`str` or ``None``
        :param status: Possible values are: 
            
            *
              :attr:`IntelligenceClusterNodeVMDeploymentStatusReport.STATUS_NOT_AVAILABLE`
            *
              :attr:`IntelligenceClusterNodeVMDeploymentStatusReport.STATUS_VM_DEPLOYMENT_QUEUED`
            *
              :attr:`IntelligenceClusterNodeVMDeploymentStatusReport.STATUS_VM_DEPLOYMENT_IN_PROGRESS`
            *
              :attr:`IntelligenceClusterNodeVMDeploymentStatusReport.STATUS_VM_DEPLOYMENT_FAILED`
            *
              :attr:`IntelligenceClusterNodeVMDeploymentStatusReport.STATUS_VM_POWER_ON_IN_PROGRESS`
            *
              :attr:`IntelligenceClusterNodeVMDeploymentStatusReport.STATUS_VM_POWER_ON_FAILED`
            *
              :attr:`IntelligenceClusterNodeVMDeploymentStatusReport.STATUS_VM_POWER_ON_SUCCESSFUL`
            *
              :attr:`IntelligenceClusterNodeVMDeploymentStatusReport.STATUS_VM_REGISTRATION_IN_PROGRESS`
            *
              :attr:`IntelligenceClusterNodeVMDeploymentStatusReport.STATUS_VM_REGISTRATION_SUCCESSFUL`
            *
              :attr:`IntelligenceClusterNodeVMDeploymentStatusReport.STATUS_VM_REGISTRATION_FAILED`
            *
              :attr:`IntelligenceClusterNodeVMDeploymentStatusReport.STATUS_VM_WAITING_TO_COME_ONLINE`
            *
              :attr:`IntelligenceClusterNodeVMDeploymentStatusReport.STATUS_VM_ONLINE_FAILED`
            *
              :attr:`IntelligenceClusterNodeVMDeploymentStatusReport.STATUS_VM_POWER_OFF_IN_PROGRESS`
            *
              :attr:`IntelligenceClusterNodeVMDeploymentStatusReport.STATUS_VM_POWER_OFF_FAILED`
            *
              :attr:`IntelligenceClusterNodeVMDeploymentStatusReport.STATUS_WAITING_TO_UNDEPLOY_VM`
            *
              :attr:`IntelligenceClusterNodeVMDeploymentStatusReport.STATUS_VM_UNDEPLOY_IN_PROGRESS`
            *
              :attr:`IntelligenceClusterNodeVMDeploymentStatusReport.STATUS_VM_UNDEPLOY_FAILED`
            *
              :attr:`IntelligenceClusterNodeVMDeploymentStatusReport.STATUS_VM_UNDEPLOY_SUCCESSFUL`
            *
              :attr:`IntelligenceClusterNodeVMDeploymentStatusReport.STATUS_UNKNOWN_STATE`
            
            Status of the addition or deletion of an auto-deployed
            NSX-Intelligence cluster node VM.
        """
        self.deployment_progress_state = deployment_progress_state
        self.failure_code = failure_code
        self.failure_message = failure_message
        self.status = status
        VapiStruct.__init__(self)


IntelligenceClusterNodeVMDeploymentStatusReport._set_binding_type(type.StructType(
    'com.vmware.nsx.model.intelligence_cluster_node_VM_deployment_status_report', {
        'deployment_progress_state': type.OptionalType(type.ReferenceType(__name__, 'ClusterNodeVMDeploymentProgressState')),
        'failure_code': type.OptionalType(type.IntegerType()),
        'failure_message': type.OptionalType(type.StringType()),
        'status': type.OptionalType(type.StringType()),
    },
    IntelligenceClusterNodeVMDeploymentStatusReport,
    False,
    None))



class IntelligenceFlowPrivateIpPrefixInfo(VapiStruct):
    """
    An IP prefix to mark the private network that NSX-Intelligence network flow
    is collected from.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    ADDRESS_TYPE_IPV4 = "IPV4"
    """


    """
    ADDRESS_TYPE_IPV6 = "IPV6"
    """


    """



    _canonical_to_pep_names = {
                            'address': 'address',
                            'address_type': 'address_type',
                            'prefix_length': 'prefix_length',
                            }

    def __init__(self,
                 address=None,
                 address_type=None,
                 prefix_length=None,
                ):
        """
        :type  address: :class:`str` or ``None``
        :param address: The prefix of IP address that marks the range of private network.
            format: ip
        :type  address_type: :class:`str` or ``None``
        :param address_type: Possible values are: 
            
            * :attr:`IntelligenceFlowPrivateIpPrefixInfo.ADDRESS_TYPE_IPV4`
            * :attr:`IntelligenceFlowPrivateIpPrefixInfo.ADDRESS_TYPE_IPV6`
            
             The type of IP address.
        :type  prefix_length: :class:`long` or ``None``
        :param prefix_length: The length of IP address prefix that marks the range of private
            network. format: int64
        """
        self.address = address
        self.address_type = address_type
        self.prefix_length = prefix_length
        VapiStruct.__init__(self)


IntelligenceFlowPrivateIpPrefixInfo._set_binding_type(type.StructType(
    'com.vmware.nsx.model.intelligence_flow_private_ip_prefix_info', {
        'address': type.OptionalType(type.StringType()),
        'address_type': type.OptionalType(type.StringType()),
        'prefix_length': type.OptionalType(type.IntegerType()),
    },
    IntelligenceFlowPrivateIpPrefixInfo,
    False,
    None))



class IntelligenceFormFactor(VapiStruct):
    """
    NSX Intelligence node form factor

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    TYPE_SMALL = "SMALL"
    """


    """
    TYPE_LARGE = "LARGE"
    """


    """
    TYPE_EXTRA_LARGE = "EXTRA_LARGE"
    """


    """



    _canonical_to_pep_names = {
                            'disk': 'disk',
                            'memory': 'memory',
                            'type': 'type',
                            'vcpu': 'vcpu',
                            }

    def __init__(self,
                 disk=None,
                 memory=None,
                 type=None,
                 vcpu=None,
                ):
        """
        :type  disk: :class:`long` or ``None``
        :param disk: Disk size of the Intelligence nodes in GBs. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  memory: :class:`long` or ``None``
        :param memory: Memory size of the Intelligence nodes in GBs format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  type: :class:`str` or ``None``
        :param type: Possible values are: 
            
            * :attr:`IntelligenceFormFactor.TYPE_SMALL`
            * :attr:`IntelligenceFormFactor.TYPE_LARGE`
            * :attr:`IntelligenceFormFactor.TYPE_EXTRA_LARGE`
            
             NSX Intelligence node form factor type
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  vcpu: :class:`long` or ``None``
        :param vcpu: Number of virtual cpus on the Intelligence nodes format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.disk = disk
        self.memory = memory
        self.type = type
        self.vcpu = vcpu
        VapiStruct.__init__(self)


IntelligenceFormFactor._set_binding_type(type.StructType(
    'com.vmware.nsx.model.intelligence_form_factor', {
        'disk': type.OptionalType(type.IntegerType()),
        'memory': type.OptionalType(type.IntegerType()),
        'type': type.OptionalType(type.StringType()),
        'vcpu': type.OptionalType(type.IntegerType()),
    },
    IntelligenceFormFactor,
    False,
    None))



class IntelligenceFormFactors(VapiStruct):
    """
    NSX Intelligence form factors list result

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'form_factors': 'form_factors',
                            }

    def __init__(self,
                 form_factors=None,
                ):
        """
        :type  form_factors: :class:`list` of :class:`IntelligenceFormFactor` or ``None``
        :param form_factors: NSX Intelligence form factor list
        """
        self.form_factors = form_factors
        VapiStruct.__init__(self)


IntelligenceFormFactors._set_binding_type(type.StructType(
    'com.vmware.nsx.model.intelligence_form_factors', {
        'form_factors': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IntelligenceFormFactor'))),
    },
    IntelligenceFormFactors,
    False,
    None))



class IntelligenceHostConfigurationInfo(VapiStruct):
    """
    NSX-Intelligence configuration that can be applied to host nodes.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'broker_bootstrap_servers': 'broker_bootstrap_servers',
                            'broker_certificate': 'broker_certificate',
                            'broker_truststore': 'broker_truststore',
                            'context_data_collection_interval': 'context_data_collection_interval',
                            'context_process_hashes': 'context_process_hashes',
                            'context_process_names': 'context_process_names',
                            'context_user_sids': 'context_user_sids',
                            'context_user_uids': 'context_user_uids',
                            'enable_context_data_collection': 'enable_context_data_collection',
                            'enable_data_collection': 'enable_data_collection',
                            'enable_flow_data_collection': 'enable_flow_data_collection',
                            'flow_data_collection_interval': 'flow_data_collection_interval',
                            'max_active_flow_count': 'max_active_flow_count',
                            'max_inactive_flow_count': 'max_inactive_flow_count',
                            'private_ip_prefix': 'private_ip_prefix',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 broker_bootstrap_servers=None,
                 broker_certificate=None,
                 broker_truststore=None,
                 context_data_collection_interval=None,
                 context_process_hashes=None,
                 context_process_names=None,
                 context_user_sids=None,
                 context_user_uids=None,
                 enable_context_data_collection=None,
                 enable_data_collection=None,
                 enable_flow_data_collection=None,
                 flow_data_collection_interval=None,
                 max_active_flow_count=None,
                 max_inactive_flow_count=None,
                 private_ip_prefix=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  broker_bootstrap_servers: :class:`list` of :class:`IntelligenceBrokerEndpointInfo` or ``None``
        :param broker_bootstrap_servers: List of NSX-Intelligence broker endpoints that host nodes contact
            initially.
        :type  broker_certificate: :class:`str` or ``None``
        :param broker_certificate: A broker certificate to verify the identity of brokers.
        :type  broker_truststore: :class:`str` or ``None``
        :param broker_truststore: A truststore to establish the trust between NSX and
            NSX-Intelligence brokers.
        :type  context_data_collection_interval: :class:`long` or ``None``
        :param context_data_collection_interval: Interval in minute of reporting VM guest context data to
            NSX-Intelligence. Recommend to keep this value the same as
            flow_data_collection_interval. format: int64
        :type  context_process_hashes: :class:`list` of :class:`str` or ``None``
        :param context_process_hashes: List of hashes of processes to collect context data. Empty implies
            all processes.
        :type  context_process_names: :class:`list` of :class:`str` or ``None``
        :param context_process_names: List of processes to collect context data. Empty implies all
            processes.
        :type  context_user_sids: :class:`list` of :class:`str` or ``None``
        :param context_user_sids: List of windows user sid to collect context data. Empty implies all
            users.
        :type  context_user_uids: :class:`list` of :class:`str` or ``None``
        :param context_user_uids: List of linux user uid to collect context data. Empty implies all
            users.
        :type  enable_context_data_collection: :class:`bool` or ``None``
        :param enable_context_data_collection: Enable NSX-Intelligence context data collection in host nodes.
        :type  enable_data_collection: :class:`bool` or ``None``
        :param enable_data_collection: Enable NSX-Intelligence data collection in host nodes. This
            property has been deprecated. To enable flow data collection, use
            property enable_flow_data_collection instead. To enable context
            data collection, use property enable_context_data_collection
            instead. When this property is set to false, no data collection is
            performed even if enable_flow_data_collection or
            enable_context_data_collection is set to true. When this property
            is set to true, property enable_flow_data_collection and
            enable_context_data_collection control whether to collect flow data
            and context data separately.
        :type  enable_flow_data_collection: :class:`bool` or ``None``
        :param enable_flow_data_collection: Enable NSX-Intelligence flow data collection in host nodes.
        :type  flow_data_collection_interval: :class:`long` or ``None``
        :param flow_data_collection_interval: Interval in minute of reporting network flow data to
            NSX-Intelligence. Recommend to keep this value the same as
            context_data_collection_interval. format: int64
        :type  max_active_flow_count: :class:`long` or ``None``
        :param max_active_flow_count: Maximum active network flow to collect in collection interval.
            format: int64
        :type  max_inactive_flow_count: :class:`long` or ``None``
        :param max_inactive_flow_count: Maximum inactive network flow to collect in collection interval.
            format: int64
        :type  private_ip_prefix: :class:`list` of :class:`IntelligenceFlowPrivateIpPrefixInfo` or ``None``
        :param private_ip_prefix: List of private IP prefix that NSX-Intelligence network flow is
            collected from.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.broker_bootstrap_servers = broker_bootstrap_servers
        self.broker_certificate = broker_certificate
        self.broker_truststore = broker_truststore
        self.context_data_collection_interval = context_data_collection_interval
        self.context_process_hashes = context_process_hashes
        self.context_process_names = context_process_names
        self.context_user_sids = context_user_sids
        self.context_user_uids = context_user_uids
        self.enable_context_data_collection = enable_context_data_collection
        self.enable_data_collection = enable_data_collection
        self.enable_flow_data_collection = enable_flow_data_collection
        self.flow_data_collection_interval = flow_data_collection_interval
        self.max_active_flow_count = max_active_flow_count
        self.max_inactive_flow_count = max_inactive_flow_count
        self.private_ip_prefix = private_ip_prefix
        VapiStruct.__init__(self)


IntelligenceHostConfigurationInfo._set_binding_type(type.StructType(
    'com.vmware.nsx.model.intelligence_host_configuration_info', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'broker_bootstrap_servers': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IntelligenceBrokerEndpointInfo'))),
        'broker_certificate': type.OptionalType(type.StringType()),
        'broker_truststore': type.OptionalType(type.StringType()),
        'context_data_collection_interval': type.OptionalType(type.IntegerType()),
        'context_process_hashes': type.OptionalType(type.ListType(type.StringType())),
        'context_process_names': type.OptionalType(type.ListType(type.StringType())),
        'context_user_sids': type.OptionalType(type.ListType(type.StringType())),
        'context_user_uids': type.OptionalType(type.ListType(type.StringType())),
        'enable_context_data_collection': type.OptionalType(type.BooleanType()),
        'enable_data_collection': type.OptionalType(type.BooleanType()),
        'enable_flow_data_collection': type.OptionalType(type.BooleanType()),
        'flow_data_collection_interval': type.OptionalType(type.IntegerType()),
        'max_active_flow_count': type.OptionalType(type.IntegerType()),
        'max_inactive_flow_count': type.OptionalType(type.IntegerType()),
        'private_ip_prefix': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IntelligenceFlowPrivateIpPrefixInfo'))),
    },
    IntelligenceHostConfigurationInfo,
    False,
    None))



class IntelligenceVsphereClusterNodeVMDeploymentConfig(VapiStruct):
    """
    The Vsphere deployment configuration determines where to deploy the
    NSX-Intelligence cluster node VM through a vCenter server. It contains
    settings that are applied during install time. If using DHCP, the following
    fields must be left unset - dns_servers, management_port_subnets, and
    default_gateway_addresses

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "IntelligenceVsphereClusterNodeVMDeploymentConfig"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    DISK_PROVISIONING_THIN = "THIN"
    """


    """
    DISK_PROVISIONING_LAZY_ZEROED_THICK = "LAZY_ZEROED_THICK"
    """


    """
    DISK_PROVISIONING_EAGER_ZEROED_THICK = "EAGER_ZEROED_THICK"
    """


    """



    _canonical_to_pep_names = {
                            'allow_ssh_root_login': 'allow_ssh_root_login',
                            'compute_id': 'compute_id',
                            'default_gateway_addresses': 'default_gateway_addresses',
                            'disk_provisioning': 'disk_provisioning',
                            'display_name': 'display_name',
                            'dns_servers': 'dns_servers',
                            'enable_ssh': 'enable_ssh',
                            'host_id': 'host_id',
                            'hostname': 'hostname',
                            'management_network_id': 'management_network_id',
                            'management_port_subnets': 'management_port_subnets',
                            'ntp_servers': 'ntp_servers',
                            'ovf_url': 'ovf_url',
                            'storage_id': 'storage_id',
                            'vc_id': 'vc_id',
                            'placement_type': 'placement_type',
                            }

    def __init__(self,
                 allow_ssh_root_login=None,
                 compute_id=None,
                 default_gateway_addresses=None,
                 disk_provisioning=None,
                 display_name=None,
                 dns_servers=None,
                 enable_ssh=None,
                 host_id=None,
                 hostname=None,
                 management_network_id=None,
                 management_port_subnets=None,
                 ntp_servers=None,
                 ovf_url=None,
                 storage_id=None,
                 vc_id=None,
                 placement_type='IntelligenceVsphereClusterNodeVMDeploymentConfig',
                ):
        """
        :type  allow_ssh_root_login: :class:`bool` or ``None``
        :param allow_ssh_root_login: If true, the root user will be allowed to log into the VM. Allowing
            root SSH logins is not recommended for security reasons.
        :type  compute_id: :class:`str` or ``None``
        :param compute_id: The NSX-Intelligence cluster node VM will be deployed on the
            specified cluster or resourcepool for specified VC server.
        :type  default_gateway_addresses: :class:`list` of :class:`str` or ``None``
        :param default_gateway_addresses: The default gateway for the VM to be deployed must be specified if
            all the other VMs it communicates with are not in the same subnet.
            Do not specify this field and management_port_subnets to use DHCP.
            Note: only single IPv4 default gateway address is supported and it
            must belong to management network. IMPORTANT: VMs deployed using
            DHCP are currently not supported, so this parameter should be
            specified. format: ip
        :type  disk_provisioning: :class:`str` or ``None``
        :param disk_provisioning: Possible values are: 
            
            *
              :attr:`IntelligenceVsphereClusterNodeVMDeploymentConfig.DISK_PROVISIONING_THIN`
            *
              :attr:`IntelligenceVsphereClusterNodeVMDeploymentConfig.DISK_PROVISIONING_LAZY_ZEROED_THICK`
            *
              :attr:`IntelligenceVsphereClusterNodeVMDeploymentConfig.DISK_PROVISIONING_EAGER_ZEROED_THICK`
            
             Specifies the disk provisioning type of the VM.
        :type  display_name: :class:`str` or ``None``
        :param display_name: Desired display name for NSX-Intelligence VM to be deployed
        :type  dns_servers: :class:`list` of :class:`str` or ``None``
        :param dns_servers: List of DNS servers. If DHCP is used, the default DNS servers
            associated with the DHCP server will be used instead. Required if
            using static IP. format: ipv4
        :type  enable_ssh: :class:`bool` or ``None``
        :param enable_ssh: If true, the SSH service will automatically be started on the VM.
            Enabling SSH service is not recommended for security reasons.
        :type  host_id: :class:`str` or ``None``
        :param host_id: The NSX-Intelligence cluster node VM will be deployed on the
            specified host in the specified VC server within the cluster if
            host_id is specified. Note: User must ensure that storage and
            specified networks are accessible by this host.
        :type  hostname: :class:`str` or ``None``
        :param hostname: Desired host name/FQDN for the VM to be deployed
        :type  management_network_id: :class:`str` or ``None``
        :param management_network_id: Distributed portgroup identifier to which the management vnic of
            NSX-Intelligence cluster node VM will be connected.
        :type  management_port_subnets: :class:`list` of :class:`IPSubnet` or ``None``
        :param management_port_subnets: IP Address and subnet configuration for the management port. Do not
            specify this field and default_gateway_addresses to use DHCP. Note:
            only one IPv4 address is supported for the management port.
            IMPORTANT: VMs deployed using DHCP are currently not supported, so
            this parameter should be specified.
        :type  ntp_servers: :class:`list` of :class:`str` or ``None``
        :param ntp_servers: List of NTP servers. To use hostnames, a DNS server must be
            defined. If not using DHCP, a DNS server should be specified under
            dns_servers. format: hostname-or-ipv4
        :type  ovf_url: :class:`str` or ``None``
        :param ovf_url: The NSX-Intelligence cluster node VM OVF URL to download and
            install the OVF file. This field is deprecated now. Please upload
            OVA file using \"/repository/bundles\" API and then try deployment
            without providing this field.
        :type  storage_id: :class:`str` or ``None``
        :param storage_id: The NSX-Intelligence cluster node VM will be deployed on the
            specified datastore in the specified VC server. User must ensure
            that storage is accessible by the specified cluster/host.
        :type  vc_id: :class:`str` or ``None``
        :param vc_id: The VC-specific identifiers will be resolved on this VC, so all
            other identifiers specified in the config must belong to this
            vCenter server.
        :type  placement_type: :class:`str`
        :param placement_type: Possible values are: 
            
            *
              :attr:`IntelligenceClusterNodeVMDeploymentConfig.PLACEMENT_TYPE_INTELLIGENCEVSPHERECLUSTERNODEVMDEPLOYMENTCONFIG`
            
            Specifies the config for the platform through which to deploy the
            VM
        """
        self.allow_ssh_root_login = allow_ssh_root_login
        self.compute_id = compute_id
        self.default_gateway_addresses = default_gateway_addresses
        self.disk_provisioning = disk_provisioning
        self.display_name = display_name
        self.dns_servers = dns_servers
        self.enable_ssh = enable_ssh
        self.host_id = host_id
        self.hostname = hostname
        self.management_network_id = management_network_id
        self.management_port_subnets = management_port_subnets
        self.ntp_servers = ntp_servers
        self.ovf_url = ovf_url
        self.storage_id = storage_id
        self.vc_id = vc_id
        self._placement_type = placement_type
        VapiStruct.__init__(self)

    @property
    def placement_type(self):
        """
        Return the discriminator value
        """
        return self._placement_type

IntelligenceVsphereClusterNodeVMDeploymentConfig._set_binding_type(type.StructType(
    'com.vmware.nsx.model.intelligence_vsphere_cluster_node_VM_deployment_config', {
        'allow_ssh_root_login': type.OptionalType(type.BooleanType()),
        'compute_id': type.OptionalType(type.StringType()),
        'default_gateway_addresses': type.OptionalType(type.ListType(type.StringType())),
        'disk_provisioning': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'dns_servers': type.OptionalType(type.ListType(type.StringType())),
        'enable_ssh': type.OptionalType(type.BooleanType()),
        'host_id': type.OptionalType(type.StringType()),
        'hostname': type.OptionalType(type.StringType()),
        'management_network_id': type.OptionalType(type.StringType()),
        'management_port_subnets': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IPSubnet'))),
        'ntp_servers': type.OptionalType(type.ListType(type.StringType())),
        'ovf_url': type.OptionalType(type.StringType()),
        'storage_id': type.OptionalType(type.StringType()),
        'vc_id': type.OptionalType(type.StringType()),
        'placement_type': type.StringType(),
    },
    IntelligenceVsphereClusterNodeVMDeploymentConfig,
    False,
    None))



class InterSRRoutingConfig(VapiStruct):
    """
    Inter SR IBGP configuration

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'enabled': 'enabled',
                            }

    def __init__(self,
                 enabled=None,
                ):
        """
        :type  enabled: :class:`bool` or ``None``
        :param enabled: While creation of BGP config this flag will be set to - true for
            Tier0 logical router with Active-Active high-availability mode -
            false for Tier0 logical router with Active-Standby
            high-availability mode. User can change this value while updating
            inter-sr config.
        """
        self.enabled = enabled
        VapiStruct.__init__(self)


InterSRRoutingConfig._set_binding_type(type.StructType(
    'com.vmware.nsx.model.inter_SR_routing_config', {
        'enabled': type.OptionalType(type.BooleanType()),
    },
    InterSRRoutingConfig,
    False,
    None))



class InterSiteBgpSummary(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'last_update_timestamp': 'last_update_timestamp',
                            'neighbor_status': 'neighbor_status',
                            'transport_node_id': 'transport_node_id',
                            }

    def __init__(self,
                 last_update_timestamp=None,
                 neighbor_status=None,
                 transport_node_id=None,
                ):
        """
        :type  last_update_timestamp: :class:`long` or ``None``
        :param last_update_timestamp: Timestamp when the inter-site IBgp neighbors status was last
            updated. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  neighbor_status: :class:`list` of :class:`BgpNeighborStatus` or ``None``
        :param neighbor_status: Status of all inter-site IBgp neighbors.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  transport_node_id: :class:`str` or ``None``
        :param transport_node_id: Edge node id whose status is being reported.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.last_update_timestamp = last_update_timestamp
        self.neighbor_status = neighbor_status
        self.transport_node_id = transport_node_id
        VapiStruct.__init__(self)


InterSiteBgpSummary._set_binding_type(type.StructType(
    'com.vmware.nsx.model.inter_site_bgp_summary', {
        'last_update_timestamp': type.OptionalType(type.IntegerType()),
        'neighbor_status': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'BgpNeighborStatus'))),
        'transport_node_id': type.OptionalType(type.StringType()),
    },
    InterSiteBgpSummary,
    False,
    None))



class InterSitePortCounters(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'blocked_packets': 'blocked_packets',
                            'dad_dropped_packets': 'dad_dropped_packets',
                            'destination_unsupported_dropped_packets': 'destination_unsupported_dropped_packets',
                            'dropped_packets': 'dropped_packets',
                            'firewall_dropped_packets': 'firewall_dropped_packets',
                            'frag_needed_dropped_packets': 'frag_needed_dropped_packets',
                            'ipsec_dropped_packets': 'ipsec_dropped_packets',
                            'ipsec_no_sa_dropped_packets': 'ipsec_no_sa_dropped_packets',
                            'ipsec_no_vti_dropped_packets': 'ipsec_no_vti_dropped_packets',
                            'ipsec_pol_block_dropped_packets': 'ipsec_pol_block_dropped_packets',
                            'ipsec_pol_err_dropped_packets': 'ipsec_pol_err_dropped_packets',
                            'ipv6_dropped_packets': 'ipv6_dropped_packets',
                            'kni_dropped_packets': 'kni_dropped_packets',
                            'l4port_unsupported_dropped_packets': 'l4port_unsupported_dropped_packets',
                            'malformed_dropped_packets': 'malformed_dropped_packets',
                            'no_arp_dropped_packets': 'no_arp_dropped_packets',
                            'no_linked_dropped_packets': 'no_linked_dropped_packets',
                            'no_mem_dropped_packets': 'no_mem_dropped_packets',
                            'no_receiver_dropped_packets': 'no_receiver_dropped_packets',
                            'no_route_dropped_packets': 'no_route_dropped_packets',
                            'non_ip_dropped_packets': 'non_ip_dropped_packets',
                            'proto_unsupported_dropped_packets': 'proto_unsupported_dropped_packets',
                            'redirect_dropped_packets': 'redirect_dropped_packets',
                            'rpf_check_dropped_packets': 'rpf_check_dropped_packets',
                            'service_insert_dropped_packets': 'service_insert_dropped_packets',
                            'total_bytes': 'total_bytes',
                            'total_packets': 'total_packets',
                            'ttl_exceeded_dropped_packets': 'ttl_exceeded_dropped_packets',
                            }

    def __init__(self,
                 blocked_packets=None,
                 dad_dropped_packets=None,
                 destination_unsupported_dropped_packets=None,
                 dropped_packets=None,
                 firewall_dropped_packets=None,
                 frag_needed_dropped_packets=None,
                 ipsec_dropped_packets=None,
                 ipsec_no_sa_dropped_packets=None,
                 ipsec_no_vti_dropped_packets=None,
                 ipsec_pol_block_dropped_packets=None,
                 ipsec_pol_err_dropped_packets=None,
                 ipv6_dropped_packets=None,
                 kni_dropped_packets=None,
                 l4port_unsupported_dropped_packets=None,
                 malformed_dropped_packets=None,
                 no_arp_dropped_packets=None,
                 no_linked_dropped_packets=None,
                 no_mem_dropped_packets=None,
                 no_receiver_dropped_packets=None,
                 no_route_dropped_packets=None,
                 non_ip_dropped_packets=None,
                 proto_unsupported_dropped_packets=None,
                 redirect_dropped_packets=None,
                 rpf_check_dropped_packets=None,
                 service_insert_dropped_packets=None,
                 total_bytes=None,
                 total_packets=None,
                 ttl_exceeded_dropped_packets=None,
                ):
        """
        :type  blocked_packets: :class:`long` or ``None``
        :param blocked_packets: The total number of packets blocked. format: int64
        :type  dad_dropped_packets: :class:`long` or ``None``
        :param dad_dropped_packets: Number of duplicate address detected packets dropped. format: int64
        :type  destination_unsupported_dropped_packets: :class:`long` or ``None``
        :param destination_unsupported_dropped_packets: Number of packtes dropped as destination is not supported. format:
            int64
        :type  dropped_packets: :class:`long` or ``None``
        :param dropped_packets: The total number of packets dropped. format: int64
        :type  firewall_dropped_packets: :class:`long` or ``None``
        :param firewall_dropped_packets: Number of firewall packets dropped. format: int64
        :type  frag_needed_dropped_packets: :class:`long` or ``None``
        :param frag_needed_dropped_packets: Number of fragmentation needed packets dropped. format: int64
        :type  ipsec_dropped_packets: :class:`long` or ``None``
        :param ipsec_dropped_packets: Number of IPSec packets dropped format: int64
        :type  ipsec_no_sa_dropped_packets: :class:`long` or ``None``
        :param ipsec_no_sa_dropped_packets: Number of IPSec no security association packets dropped. format:
            int64
        :type  ipsec_no_vti_dropped_packets: :class:`long` or ``None``
        :param ipsec_no_vti_dropped_packets: Number of IPSec packets dropped as no VTI is present. format: int64
        :type  ipsec_pol_block_dropped_packets: :class:`long` or ``None``
        :param ipsec_pol_block_dropped_packets: Number of IPSec policy block packets dropped. format: int64
        :type  ipsec_pol_err_dropped_packets: :class:`long` or ``None``
        :param ipsec_pol_err_dropped_packets: Number of IPSec policy error packets dropped. format: int64
        :type  ipv6_dropped_packets: :class:`long` or ``None``
        :param ipv6_dropped_packets: Number of IPV6 packets dropped. format: int64
        :type  kni_dropped_packets: :class:`long` or ``None``
        :param kni_dropped_packets: Number of DPDK kernal NIC interface packets dropped. format: int64
        :type  l4port_unsupported_dropped_packets: :class:`long` or ``None``
        :param l4port_unsupported_dropped_packets: Number of packets dropped due to unsupported L4 port. format: int64
        :type  malformed_dropped_packets: :class:`long` or ``None``
        :param malformed_dropped_packets: Number of packtes dropped as they are malformed. format: int64
        :type  no_arp_dropped_packets: :class:`long` or ``None``
        :param no_arp_dropped_packets: Number of no ARP packets dropped. format: int64
        :type  no_linked_dropped_packets: :class:`long` or ``None``
        :param no_linked_dropped_packets: Number of packets dropped as no linked ports are present. format:
            int64
        :type  no_mem_dropped_packets: :class:`long` or ``None``
        :param no_mem_dropped_packets: Number of packets dropped due to insufficient memory. format: int64
        :type  no_receiver_dropped_packets: :class:`long` or ``None``
        :param no_receiver_dropped_packets: Number of packets dropped due to absence of receiver. format: int64
        :type  no_route_dropped_packets: :class:`long` or ``None``
        :param no_route_dropped_packets: The number of no route packets dropped format: int64
        :type  non_ip_dropped_packets: :class:`long` or ``None``
        :param non_ip_dropped_packets: Number of non IP packets dropped. format: int64
        :type  proto_unsupported_dropped_packets: :class:`long` or ``None``
        :param proto_unsupported_dropped_packets: Number of packets dropped as protocol is unsupported. format: int64
        :type  redirect_dropped_packets: :class:`long` or ``None``
        :param redirect_dropped_packets: Number of redirect packets dropped. format: int64
        :type  rpf_check_dropped_packets: :class:`long` or ``None``
        :param rpf_check_dropped_packets: Number of reverse-path forwarding check packets dropped. format:
            int64
        :type  service_insert_dropped_packets: :class:`long` or ``None``
        :param service_insert_dropped_packets: Number of service insert packets dropped. format: int64
        :type  total_bytes: :class:`long` or ``None``
        :param total_bytes: The total number of bytes transferred. format: int64
        :type  total_packets: :class:`long` or ``None``
        :param total_packets: The total number of packets transferred. format: int64
        :type  ttl_exceeded_dropped_packets: :class:`long` or ``None``
        :param ttl_exceeded_dropped_packets: Number of time to live exceeded packets dropped. format: int64
        """
        self.blocked_packets = blocked_packets
        self.dad_dropped_packets = dad_dropped_packets
        self.destination_unsupported_dropped_packets = destination_unsupported_dropped_packets
        self.dropped_packets = dropped_packets
        self.firewall_dropped_packets = firewall_dropped_packets
        self.frag_needed_dropped_packets = frag_needed_dropped_packets
        self.ipsec_dropped_packets = ipsec_dropped_packets
        self.ipsec_no_sa_dropped_packets = ipsec_no_sa_dropped_packets
        self.ipsec_no_vti_dropped_packets = ipsec_no_vti_dropped_packets
        self.ipsec_pol_block_dropped_packets = ipsec_pol_block_dropped_packets
        self.ipsec_pol_err_dropped_packets = ipsec_pol_err_dropped_packets
        self.ipv6_dropped_packets = ipv6_dropped_packets
        self.kni_dropped_packets = kni_dropped_packets
        self.l4port_unsupported_dropped_packets = l4port_unsupported_dropped_packets
        self.malformed_dropped_packets = malformed_dropped_packets
        self.no_arp_dropped_packets = no_arp_dropped_packets
        self.no_linked_dropped_packets = no_linked_dropped_packets
        self.no_mem_dropped_packets = no_mem_dropped_packets
        self.no_receiver_dropped_packets = no_receiver_dropped_packets
        self.no_route_dropped_packets = no_route_dropped_packets
        self.non_ip_dropped_packets = non_ip_dropped_packets
        self.proto_unsupported_dropped_packets = proto_unsupported_dropped_packets
        self.redirect_dropped_packets = redirect_dropped_packets
        self.rpf_check_dropped_packets = rpf_check_dropped_packets
        self.service_insert_dropped_packets = service_insert_dropped_packets
        self.total_bytes = total_bytes
        self.total_packets = total_packets
        self.ttl_exceeded_dropped_packets = ttl_exceeded_dropped_packets
        VapiStruct.__init__(self)


InterSitePortCounters._set_binding_type(type.StructType(
    'com.vmware.nsx.model.inter_site_port_counters', {
        'blocked_packets': type.OptionalType(type.IntegerType()),
        'dad_dropped_packets': type.OptionalType(type.IntegerType()),
        'destination_unsupported_dropped_packets': type.OptionalType(type.IntegerType()),
        'dropped_packets': type.OptionalType(type.IntegerType()),
        'firewall_dropped_packets': type.OptionalType(type.IntegerType()),
        'frag_needed_dropped_packets': type.OptionalType(type.IntegerType()),
        'ipsec_dropped_packets': type.OptionalType(type.IntegerType()),
        'ipsec_no_sa_dropped_packets': type.OptionalType(type.IntegerType()),
        'ipsec_no_vti_dropped_packets': type.OptionalType(type.IntegerType()),
        'ipsec_pol_block_dropped_packets': type.OptionalType(type.IntegerType()),
        'ipsec_pol_err_dropped_packets': type.OptionalType(type.IntegerType()),
        'ipv6_dropped_packets': type.OptionalType(type.IntegerType()),
        'kni_dropped_packets': type.OptionalType(type.IntegerType()),
        'l4port_unsupported_dropped_packets': type.OptionalType(type.IntegerType()),
        'malformed_dropped_packets': type.OptionalType(type.IntegerType()),
        'no_arp_dropped_packets': type.OptionalType(type.IntegerType()),
        'no_linked_dropped_packets': type.OptionalType(type.IntegerType()),
        'no_mem_dropped_packets': type.OptionalType(type.IntegerType()),
        'no_receiver_dropped_packets': type.OptionalType(type.IntegerType()),
        'no_route_dropped_packets': type.OptionalType(type.IntegerType()),
        'non_ip_dropped_packets': type.OptionalType(type.IntegerType()),
        'proto_unsupported_dropped_packets': type.OptionalType(type.IntegerType()),
        'redirect_dropped_packets': type.OptionalType(type.IntegerType()),
        'rpf_check_dropped_packets': type.OptionalType(type.IntegerType()),
        'service_insert_dropped_packets': type.OptionalType(type.IntegerType()),
        'total_bytes': type.OptionalType(type.IntegerType()),
        'total_packets': type.OptionalType(type.IntegerType()),
        'ttl_exceeded_dropped_packets': type.OptionalType(type.IntegerType()),
    },
    InterSitePortCounters,
    False,
    None))



class InterfaceNeighborProperties(VapiStruct):
    """
    Interface neighbor properties

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'ifindex': 'ifindex',
                            'mac': 'mac',
                            'name': 'name',
                            'neighbors': 'neighbors',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 ifindex=None,
                 mac=None,
                 name=None,
                 neighbors=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  ifindex: :class:`long` or ``None``
        :param ifindex: Interface index format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  mac: :class:`str` or ``None``
        :param mac: Interface MAC address
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  name: :class:`str` or ``None``
        :param name: Interface Name
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  neighbors: :class:`list` of :class:`NeighborProperties` or ``None``
        :param neighbors: Neighbor properties
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.ifindex = ifindex
        self.mac = mac
        self.name = name
        self.neighbors = neighbors
        VapiStruct.__init__(self)


InterfaceNeighborProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.interface_neighbor_properties', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'ifindex': type.OptionalType(type.IntegerType()),
        'mac': type.OptionalType(type.StringType()),
        'name': type.OptionalType(type.StringType()),
        'neighbors': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NeighborProperties'))),
    },
    InterfaceNeighborProperties,
    False,
    None))



class InterfaceNeighborPropertyListResult(VapiStruct):
    """
    Interface neighbor property query results

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`InterfaceNeighborProperties` or ``None``
        :param results: Interface neighbor property results
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


InterfaceNeighborPropertyListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.interface_neighbor_property_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'InterfaceNeighborProperties'))),
    },
    InterfaceNeighborPropertyListResult,
    False,
    None))



class InterfacePimConfig(VapiStruct):
    """
    Interface PIM[Protocol Independent Multicast] configuration parameters.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'enabled': 'enabled',
                            }

    def __init__(self,
                 enabled=None,
                ):
        """
        :type  enabled: :class:`bool` or ``None``
        :param enabled: If the flag is set to true - it will enable PIM on the uplink
            interface. If the flag is set to false - it will disable PIM on the
            uplink interface.
        """
        self.enabled = enabled
        VapiStruct.__init__(self)


InterfacePimConfig._set_binding_type(type.StructType(
    'com.vmware.nsx.model.interface_pim_config', {
        'enabled': type.OptionalType(type.BooleanType()),
    },
    InterfacePimConfig,
    False,
    None))



class IntervalBackupSchedule(VapiStruct):
    """
    Schedule to specify the interval time at which automated backups need to be
    taken

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "IntervalBackupSchedule"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'seconds_between_backups': 'seconds_between_backups',
                            'resource_type': 'resource_type',
                            }

    def __init__(self,
                 seconds_between_backups=None,
                 resource_type='IntervalBackupSchedule',
                ):
        """
        :type  seconds_between_backups: :class:`long` or ``None``
        :param seconds_between_backups: Time interval in seconds between two consecutive automated backups
            format: int64
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`BackupSchedule.RESOURCE_TYPE_WEEKLYBACKUPSCHEDULE`
            * :attr:`BackupSchedule.RESOURCE_TYPE_INTERVALBACKUPSCHEDULE`
            
             Schedule type
        """
        self.seconds_between_backups = seconds_between_backups
        self._resource_type = resource_type
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

IntervalBackupSchedule._set_binding_type(type.StructType(
    'com.vmware.nsx.model.interval_backup_schedule', {
        'seconds_between_backups': type.OptionalType(type.IntegerType()),
        'resource_type': type.StringType(),
    },
    IntervalBackupSchedule,
    False,
    None))



class InventoryConfig(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'compute_managers_soft_limit': 'compute_managers_soft_limit',
                            }

    def __init__(self,
                 compute_managers_soft_limit=None,
                ):
        """
        :type  compute_managers_soft_limit: :class:`long` or ``None``
        :param compute_managers_soft_limit: Soft limit on number of compute managers, which can be added,
            beyond which, addition of compute managers will result in warning
            getting logged format: int32
        """
        self.compute_managers_soft_limit = compute_managers_soft_limit
        VapiStruct.__init__(self)


InventoryConfig._set_binding_type(type.StructType(
    'com.vmware.nsx.model.inventory_config', {
        'compute_managers_soft_limit': type.OptionalType(type.IntegerType()),
    },
    InventoryConfig,
    False,
    None))



class IpAddressInfo(VapiStruct):
    """
    Ipaddress information of the fabric node.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    SOURCE_TOOLS = "VM_TOOLS"
    """


    """



    _canonical_to_pep_names = {
                            'ip_addresses': 'ip_addresses',
                            'source': 'source',
                            }

    def __init__(self,
                 ip_addresses=None,
                 source=None,
                ):
        """
        :type  ip_addresses: :class:`list` of :class:`str` or ``None``
        :param ip_addresses: IP Addresses of the the virtual network interface, as discovered in
            the source. format: ip
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  source: :class:`str` or ``None``
        :param source: Possible values are: 
            
            * :attr:`IpAddressInfo.SOURCE_TOOLS`
            
             Source of the ipaddress information.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.ip_addresses = ip_addresses
        self.source = source
        VapiStruct.__init__(self)


IpAddressInfo._set_binding_type(type.StructType(
    'com.vmware.nsx.model.ip_address_info', {
        'ip_addresses': type.OptionalType(type.ListType(type.StringType())),
        'source': type.OptionalType(type.StringType()),
    },
    IpAddressInfo,
    False,
    None))



class IpAllocationBase(VapiStruct):
    """
    Base type of ip-allocation extended by ip pool and static binding.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'gateway_ip': 'gateway_ip',
                            'lease_time': 'lease_time',
                            'options': 'options',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 gateway_ip=None,
                 lease_time=None,
                 options=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  gateway_ip: :class:`str` or ``None``
        :param gateway_ip: Gateway ip address of the allocation. format: ip
        :type  lease_time: :class:`long` or ``None``
        :param lease_time: Lease time, in seconds, [60-(2^32-1)]. Default is 86400. format:
            int64
        :type  options: :class:`DhcpOptions` or ``None``
        :param options: If an option is defined at server level and not configred at
            ip-pool/static-binding level, the option will be inherited to
            ip-pool/static-binding. If both define a same-code option, the
            option defined at ip-pool/static-binding level take precedence over
            that defined at server level.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.gateway_ip = gateway_ip
        self.lease_time = lease_time
        self.options = options
        VapiStruct.__init__(self)


IpAllocationBase._set_binding_type(type.StructType(
    'com.vmware.nsx.model.ip_allocation_base', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'gateway_ip': type.OptionalType(type.StringType()),
        'lease_time': type.OptionalType(type.IntegerType()),
        'options': type.OptionalType(type.ReferenceType(__name__, 'DhcpOptions')),
    },
    IpAllocationBase,
    False,
    None))



class IpAssignmentSpec(VapiStruct):
    """
    Abstract base type for specification of IPs to be used with host switch
    virtual tunnel endpoints

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "IpAssignmentSpec"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    RESOURCE_TYPE_STATICIPPOOLSPEC = "StaticIpPoolSpec"
    """


    """
    RESOURCE_TYPE_STATICIPLISTSPEC = "StaticIpListSpec"
    """


    """
    RESOURCE_TYPE_ASSIGNEDBYDHCP = "AssignedByDhcp"
    """


    """
    RESOURCE_TYPE_STATICIPMACLISTSPEC = "StaticIpMacListSpec"
    """


    """



    _canonical_to_pep_names = {
                            'resource_type': 'resource_type',
                            }

    def __init__(self,
                 resource_type='IpAssignmentSpec',
                ):
        """
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`IpAssignmentSpec.RESOURCE_TYPE_STATICIPPOOLSPEC`
            * :attr:`IpAssignmentSpec.RESOURCE_TYPE_STATICIPLISTSPEC`
            * :attr:`IpAssignmentSpec.RESOURCE_TYPE_ASSIGNEDBYDHCP`
            * :attr:`IpAssignmentSpec.RESOURCE_TYPE_STATICIPMACLISTSPEC`
        """
        self._resource_type = resource_type
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

IpAssignmentSpec._set_binding_type(type.StructType(
    'com.vmware.nsx.model.ip_assignment_spec', {
        'resource_type': type.StringType(),
    },
    IpAssignmentSpec,
    False,
    None))



class IpBlock(VapiStruct):
    """
    A block of IPv4/IPv6 addresses defined by a start address and a mask/prefix
    (network CIDR). An IP block is typically large & allocated to a tenant for
    automated consumption. An IP block is always a contiguous address space,
    for example 192.0.0.1/8. An IP block can be further subdivided into subnets
    called IP block subnets. These IP block subnets can later be added to IP
    pools and used for IP allocation. An IP pool is typically a collection of
    subnets that are often not a contiguous address space. Clients are
    allocated IP addresses only from IP pools. Sample Structure Diagram
    IpBlock_VMware 192.0.0.1/8
    ======================================================================= /
    ___________________________________________/________ /
    IpBlockSubnet_Finance ( IpBlockSubnet_Eng1 IpBlockSubnet_Eng2 / ) /
    192.168.0.1/16 ( 192.170.1.1/16 192.180.1.1/24 / ) IpPool_Eng /
    (___________________________________________/________) / /
    =======================================================================

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'cidr': 'cidr',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 cidr=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  cidr: :class:`str` or ``None``
        :param cidr: Represents network address and the prefix length which will be
            associated with a layer-2 broadcast domain format: ip-cidr-block
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.cidr = cidr
        VapiStruct.__init__(self)


IpBlock._set_binding_type(type.StructType(
    'com.vmware.nsx.model.ip_block', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'cidr': type.OptionalType(type.StringType()),
    },
    IpBlock,
    False,
    None))



class IpBlockListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`IpBlock` or ``None``
        :param results: IP block list results
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


IpBlockListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.ip_block_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IpBlock'))),
    },
    IpBlockListResult,
    False,
    None))



class IpBlockSubnet(VapiStruct):
    """
    A set of IPv4/IPv6 addresses defined by a start address and a mask/prefix
    which will typically be associated with a layer-2 broadcast domain.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'allocation_ranges': 'allocation_ranges',
                            'block_id': 'block_id',
                            'cidr': 'cidr',
                            'size': 'size',
                            'start_ip': 'start_ip',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 allocation_ranges=None,
                 block_id=None,
                 cidr=None,
                 size=None,
                 start_ip=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  allocation_ranges: :class:`list` of :class:`IpPoolRange` or ``None``
        :param allocation_ranges: A collection of IPv4/IPv6 IP ranges used for IP allocation.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  block_id: :class:`str` or ``None``
        :param block_id: Block id for which the subnet is created.
        :type  cidr: :class:`str` or ``None``
        :param cidr: Represents network address and the prefix length which will be
            associated with a layer-2 broadcast domain format: ip-cidr-block
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  size: :class:`long` or ``None``
        :param size: Represents the size or number of ip addresses in the subnet format:
            int64
        :type  start_ip: :class:`str` or ``None``
        :param start_ip: For internal system use Only. Represents start ip address of the
            subnet from IP block. Subnet ip adddress will start from this ip
            address. format: ip
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.allocation_ranges = allocation_ranges
        self.block_id = block_id
        self.cidr = cidr
        self.size = size
        self.start_ip = start_ip
        VapiStruct.__init__(self)


IpBlockSubnet._set_binding_type(type.StructType(
    'com.vmware.nsx.model.ip_block_subnet', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'allocation_ranges': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IpPoolRange'))),
        'block_id': type.OptionalType(type.StringType()),
        'cidr': type.OptionalType(type.StringType()),
        'size': type.OptionalType(type.IntegerType()),
        'start_ip': type.OptionalType(type.StringType()),
    },
    IpBlockSubnet,
    False,
    None))



class IpBlockSubnetListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`IpBlockSubnet` or ``None``
        :param results: IP block subnet list results
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


IpBlockSubnetListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.ip_block_subnet_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IpBlockSubnet'))),
    },
    IpBlockSubnetListResult,
    False,
    None))



class IpDiscoverySwitchingProfile(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "IpDiscoverySwitchingProfile"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'arp_bindings_limit': 'arp_bindings_limit',
                            'arp_nd_binding_timeout': 'arp_nd_binding_timeout',
                            'arp_snooping_enabled': 'arp_snooping_enabled',
                            'dhcp_snooping_enabled': 'dhcp_snooping_enabled',
                            'dhcpv6_snooping_enabled': 'dhcpv6_snooping_enabled',
                            'duplicate_ip_detection': 'duplicate_ip_detection',
                            'nd_bindings_limit': 'nd_bindings_limit',
                            'nd_snooping_enabled': 'nd_snooping_enabled',
                            'trust_on_first_use_enabled': 'trust_on_first_use_enabled',
                            'vm_tools_enabled': 'vm_tools_enabled',
                            'vm_tools_v6_enabled': 'vm_tools_v6_enabled',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'required_capabilities': 'required_capabilities',
                            }

    def __init__(self,
                 arp_bindings_limit=None,
                 arp_nd_binding_timeout=None,
                 arp_snooping_enabled=None,
                 dhcp_snooping_enabled=None,
                 dhcpv6_snooping_enabled=None,
                 duplicate_ip_detection=None,
                 nd_bindings_limit=None,
                 nd_snooping_enabled=None,
                 trust_on_first_use_enabled=None,
                 vm_tools_enabled=None,
                 vm_tools_v6_enabled=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='IpDiscoverySwitchingProfile',
                 tags=None,
                 required_capabilities=None,
                ):
        """
        :type  arp_bindings_limit: :class:`long` or ``None``
        :param arp_bindings_limit: Indicates the number of arp snooped IP addresses to be remembered
            per LogicalPort. Decreasing this value, will retain the latest
            bindings from the existing list of address bindings. Increasing
            this value will retain existing bindings and also learn any new
            address bindings discovered on the port until the new limit is
            reached. This limit only applies to IPv4 addresses and is
            independent of the nd_bindings_limit used for IPv6 snooping.
            format: int32
        :type  arp_nd_binding_timeout: :class:`long` or ``None``
        :param arp_nd_binding_timeout: This property controls the ARP and ND cache timeout period.It is
            recommended that this property be greater than the ARP/ND cache
            timeout on the VM. format: int32
        :type  arp_snooping_enabled: :class:`bool` or ``None``
        :param arp_snooping_enabled: Indicates whether ARP snooping is enabled
        :type  dhcp_snooping_enabled: :class:`bool` or ``None``
        :param dhcp_snooping_enabled: Indicates whether DHCP snooping is enabled
        :type  dhcpv6_snooping_enabled: :class:`bool` or ``None``
        :param dhcpv6_snooping_enabled: This option is the IPv6 equivalent of DHCP snooping.
        :type  duplicate_ip_detection: :class:`DuplicateIPDetection` or ``None``
        :param duplicate_ip_detection: Duplicate IP detection is used to determine if there is any IP
            conflict with any other port on the same logical switch. If a
            conflict is detected, then the IP is marked as a duplicate on the
            port where the IP was discovered last. The duplicate IP will not be
            added to the realized address binings for the port and hence will
            not be used in DFW rules or other security configurations for the
            port.
        :type  nd_bindings_limit: :class:`long` or ``None``
        :param nd_bindings_limit: Indicates the number of neighbor-discovery snooped IP addresses to
            be remembered per LogicalPort. Decreasing this value, will retain
            the latest bindings from the existing list of address bindings.
            Increasing this value will retain existing bindings and also learn
            any new address bindings discovered on the port until the new limit
            is reached. This limit only applies to IPv6 addresses and is
            independent of the arp_bindings_limit used for IPv4 snooping.
            format: int32
        :type  nd_snooping_enabled: :class:`bool` or ``None``
        :param nd_snooping_enabled: This option is the IPv6 equivalent of ARP snooping.
        :type  trust_on_first_use_enabled: :class:`bool` or ``None``
        :param trust_on_first_use_enabled: ARP snooping being inherently susceptible to ARP spoofing, uses a
            turst-on-fisrt-use (TOFU) paradigm where only the first IP address
            discovered via ARP snooping is trusted. The remaining are ignored.
            In order to allow for more flexibility, we allow the user to
            configure how many ARP snooped address bindings should be trusted
            for the lifetime of the logical port. This is controlled by the
            arp_bindings_limit property in the IP Discovery profile. We refer
            to this extension of TOFU as N-TOFU. However, if TOFU is disabled,
            then N ARP snooped IP addresses will be trusted until they are
            timed out, where N is configured by arp_bindings_limit.
        :type  vm_tools_enabled: :class:`bool` or ``None``
        :param vm_tools_enabled: This option is only supported on ESX where vm-tools is installed.
        :type  vm_tools_v6_enabled: :class:`bool` or ``None``
        :param vm_tools_v6_enabled: This option is only supported on ESX where vm-tools is installed.
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: 
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  required_capabilities: :class:`list` of :class:`str` or ``None``
        :param required_capabilities: 
        """
        self.arp_bindings_limit = arp_bindings_limit
        self.arp_nd_binding_timeout = arp_nd_binding_timeout
        self.arp_snooping_enabled = arp_snooping_enabled
        self.dhcp_snooping_enabled = dhcp_snooping_enabled
        self.dhcpv6_snooping_enabled = dhcpv6_snooping_enabled
        self.duplicate_ip_detection = duplicate_ip_detection
        self.nd_bindings_limit = nd_bindings_limit
        self.nd_snooping_enabled = nd_snooping_enabled
        self.trust_on_first_use_enabled = trust_on_first_use_enabled
        self.vm_tools_enabled = vm_tools_enabled
        self.vm_tools_v6_enabled = vm_tools_v6_enabled
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        self.required_capabilities = required_capabilities
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

IpDiscoverySwitchingProfile._set_binding_type(type.StructType(
    'com.vmware.nsx.model.ip_discovery_switching_profile', {
        'arp_bindings_limit': type.OptionalType(type.IntegerType()),
        'arp_nd_binding_timeout': type.OptionalType(type.IntegerType()),
        'arp_snooping_enabled': type.OptionalType(type.BooleanType()),
        'dhcp_snooping_enabled': type.OptionalType(type.BooleanType()),
        'dhcpv6_snooping_enabled': type.OptionalType(type.BooleanType()),
        'duplicate_ip_detection': type.OptionalType(type.ReferenceType(__name__, 'DuplicateIPDetection')),
        'nd_bindings_limit': type.OptionalType(type.IntegerType()),
        'nd_snooping_enabled': type.OptionalType(type.BooleanType()),
        'trust_on_first_use_enabled': type.OptionalType(type.BooleanType()),
        'vm_tools_enabled': type.OptionalType(type.BooleanType()),
        'vm_tools_v6_enabled': type.OptionalType(type.BooleanType()),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'required_capabilities': type.OptionalType(type.ListType(type.StringType())),
    },
    IpDiscoverySwitchingProfile,
    False,
    None))



class IpMacPair(VapiStruct):
    """
    IP and MAC pair.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'ip': 'ip',
                            'mac': 'mac',
                            }

    def __init__(self,
                 ip=None,
                 mac=None,
                ):
        """
        :type  ip: :class:`str` or ``None``
        :param ip: IP address format: ip
        :type  mac: :class:`str` or ``None``
        :param mac: MAC address format: mac-address
        """
        self.ip = ip
        self.mac = mac
        VapiStruct.__init__(self)


IpMacPair._set_binding_type(type.StructType(
    'com.vmware.nsx.model.ip_mac_pair', {
        'ip': type.OptionalType(type.StringType()),
        'mac': type.OptionalType(type.StringType()),
    },
    IpMacPair,
    False,
    None))



class IpPool(VapiStruct):
    """
    A collection of one or more IPv4 or IPv6 subnets or ranges that are often
    not a contiguous address space. Clients are allocated IPs from an IP pool.
    Often used when a client that consumes addresses exhausts an initial subnet
    or range and needs to be expanded but the adjoining address space is not
    available as it has been allocated to a different client.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'ip_release_delay': 'ip_release_delay',
                            'pool_usage': 'pool_usage',
                            'subnets': 'subnets',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 ip_release_delay=None,
                 pool_usage=None,
                 subnets=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  ip_release_delay: :class:`long` or ``None``
        :param ip_release_delay: Delay in milliseconds, while releasing allocated IP address from IP
            pool (Default is 2 mins). format: int64
        :type  pool_usage: :class:`PoolUsage` or ``None``
        :param pool_usage: Pool usage statistics
        :type  subnets: :class:`list` of :class:`IpPoolSubnet` or ``None``
        :param subnets: Subnets can be IPv4 or IPv6 and they should not overlap. The
            maximum number will not exceed 5 subnets.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.ip_release_delay = ip_release_delay
        self.pool_usage = pool_usage
        self.subnets = subnets
        VapiStruct.__init__(self)


IpPool._set_binding_type(type.StructType(
    'com.vmware.nsx.model.ip_pool', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'ip_release_delay': type.OptionalType(type.IntegerType()),
        'pool_usage': type.OptionalType(type.ReferenceType(__name__, 'PoolUsage')),
        'subnets': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IpPoolSubnet'))),
    },
    IpPool,
    False,
    None))



class IpPoolListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`IpPool` or ``None``
        :param results: IP pool list results
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


IpPoolListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.ip_pool_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IpPool'))),
    },
    IpPoolListResult,
    False,
    None))



class IpPoolRange(VapiStruct):
    """
    A set of IPv4 or IPv6 addresses defined by a start and end address.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'end': 'end',
                            'start': 'start',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 end=None,
                 start=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  end: :class:`str` or ``None``
        :param end: The end IP Address of the IP Range. format: ip
        :type  start: :class:`str` or ``None``
        :param start: The start IP Address of the IP Range. format: ip
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.end = end
        self.start = start
        VapiStruct.__init__(self)


IpPoolRange._set_binding_type(type.StructType(
    'com.vmware.nsx.model.ip_pool_range', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'end': type.OptionalType(type.StringType()),
        'start': type.OptionalType(type.StringType()),
    },
    IpPoolRange,
    False,
    None))



class IpPoolSubnet(VapiStruct):
    """
    A set of IPv4 or IPv6 addresses defined by a network CIDR.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'allocation_ranges': 'allocation_ranges',
                            'cidr': 'cidr',
                            'dns_nameservers': 'dns_nameservers',
                            'dns_suffix': 'dns_suffix',
                            'gateway_ip': 'gateway_ip',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 allocation_ranges=None,
                 cidr=None,
                 dns_nameservers=None,
                 dns_suffix=None,
                 gateway_ip=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  allocation_ranges: :class:`list` of :class:`IpPoolRange` or ``None``
        :param allocation_ranges: A collection of IPv4 or IPv6 IP Pool Ranges.
        :type  cidr: :class:`str` or ``None``
        :param cidr: Represents network address and the prefix length which will be
            associated with a layer-2 broadcast domain
        :type  dns_nameservers: :class:`list` of :class:`str` or ``None``
        :param dns_nameservers: The collection of upto 3 DNS servers for the subnet. format: ip
        :type  dns_suffix: :class:`str` or ``None``
        :param dns_suffix: The DNS suffix for the DNS server. format: hostname
        :type  gateway_ip: :class:`str` or ``None``
        :param gateway_ip: The default gateway address on a layer-3 router. format: ip
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.allocation_ranges = allocation_ranges
        self.cidr = cidr
        self.dns_nameservers = dns_nameservers
        self.dns_suffix = dns_suffix
        self.gateway_ip = gateway_ip
        VapiStruct.__init__(self)


IpPoolSubnet._set_binding_type(type.StructType(
    'com.vmware.nsx.model.ip_pool_subnet', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'allocation_ranges': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IpPoolRange'))),
        'cidr': type.OptionalType(type.StringType()),
        'dns_nameservers': type.OptionalType(type.ListType(type.StringType())),
        'dns_suffix': type.OptionalType(type.StringType()),
        'gateway_ip': type.OptionalType(type.StringType()),
    },
    IpPoolSubnet,
    False,
    None))



class IpfixCollector(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'collector_ip_address': 'collector_ip_address',
                            'collector_port': 'collector_port',
                            }

    def __init__(self,
                 collector_ip_address=None,
                 collector_port=None,
                ):
        """
        :type  collector_ip_address: :class:`str` or ``None``
        :param collector_ip_address: IP address for the IPFIX collector format: ip
        :type  collector_port: :class:`long` or ``None``
        :param collector_port: Port for the IPFIX collector format: int32
        """
        self.collector_ip_address = collector_ip_address
        self.collector_port = collector_port
        VapiStruct.__init__(self)


IpfixCollector._set_binding_type(type.StructType(
    'com.vmware.nsx.model.ipfix_collector', {
        'collector_ip_address': type.OptionalType(type.StringType()),
        'collector_port': type.OptionalType(type.IntegerType()),
    },
    IpfixCollector,
    False,
    None))



class IpfixCollectorConfig(VapiStruct):
    """
    This managed entity contains a set of IPFIX collectors.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'collectors': 'collectors',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 collectors=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  collectors: :class:`list` of :class:`IpfixCollector` or ``None``
        :param collectors: IPFIX Collectors
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.collectors = collectors
        VapiStruct.__init__(self)


IpfixCollectorConfig._set_binding_type(type.StructType(
    'com.vmware.nsx.model.ipfix_collector_config', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'collectors': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IpfixCollector'))),
    },
    IpfixCollectorConfig,
    False,
    None))



class IpfixCollectorConfigListResult(VapiStruct):
    """
    List of IPFIX Collector Configs

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`IpfixCollectorConfig` or ``None``
        :param results: IPFIX Collector Config
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


IpfixCollectorConfigListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.ipfix_collector_config_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IpfixCollectorConfig'))),
    },
    IpfixCollectorConfigListResult,
    False,
    None))



class IpfixCollectorUpmProfile(VapiStruct):
    """
    The configuration for Internet protocol flow information export (IPFIX)
    collector. It should be referenced in other IPFIX profile as a collecor
    config. The IPFIX exporter will send records to these collectors.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    RESOURCE_TYPE_IPFIXCOLLECTORUPMPROFILE = "IpfixCollectorUpmProfile"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'collectors': 'collectors',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 collectors=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: Possible values are: 
            
            *
              :attr:`IpfixCollectorUpmProfile.RESOURCE_TYPE_IPFIXCOLLECTORUPMPROFILE`
            
             All IPFIX collector profile types.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  collectors: :class:`list` of :class:`IpfixCollector` or ``None``
        :param collectors: IPFIX Collector Set
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.collectors = collectors
        VapiStruct.__init__(self)


IpfixCollectorUpmProfile._set_binding_type(type.StructType(
    'com.vmware.nsx.model.ipfix_collector_upm_profile', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'collectors': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IpfixCollector'))),
    },
    IpfixCollectorUpmProfile,
    False,
    None))



class IpfixCollectorUpmProfileListResult(VapiStruct):
    """
    IPFIX collector profile list result for query with profile list parameters

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`IpfixCollectorUpmProfile` or ``None``
        :param results: IPFIX Collector Profile List
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


IpfixCollectorUpmProfileListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.ipfix_collector_upm_profile_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IpfixCollectorUpmProfile'))),
    },
    IpfixCollectorUpmProfileListResult,
    False,
    None))



class IpfixConfig(VapiStruct):
    """
    IPFIX Config base representation

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "IpfixConfig"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    RESOURCE_TYPE_IPFIXSWITCHCONFIG = "IpfixSwitchConfig"
    """


    """
    RESOURCE_TYPE_IPFIXDFWCONFIG = "IpfixDfwConfig"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'applied_tos': 'applied_tos',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='IpfixConfig',
                 tags=None,
                 applied_tos=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`IpfixConfig.RESOURCE_TYPE_IPFIXSWITCHCONFIG`
            * :attr:`IpfixConfig.RESOURCE_TYPE_IPFIXDFWCONFIG`
            
             Supported IPFIX Config Types.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  applied_tos: :class:`list` of :class:`ResourceReference` or ``None``
        :param applied_tos: List of objects where the IPFIX Config will be enabled.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        self.applied_tos = applied_tos
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

IpfixConfig._set_binding_type(type.StructType(
    'com.vmware.nsx.model.ipfix_config', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'applied_tos': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceReference'))),
    },
    IpfixConfig,
    False,
    None))



class IpfixConfigListResult(VapiStruct):
    """
    List of IPFIX Config

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param results: IPFIX Config
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`IpfixConfig`. When methods return a value of this class as
            a return value, the attribute will contain all the attributes
            defined in :class:`IpfixConfig`.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


IpfixConfigListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.ipfix_config_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'IpfixConfig')]))),
    },
    IpfixConfigListResult,
    False,
    None))



class IpfixDfwConfig(VapiStruct):
    """
    It defines IPFIX DFW Configuration.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "IpfixDfwConfig"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'active_flow_export_timeout': 'active_flow_export_timeout',
                            'collector': 'collector',
                            'observation_domain_id': 'observation_domain_id',
                            'priority': 'priority',
                            'template_parameters': 'template_parameters',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'applied_tos': 'applied_tos',
                            }

    def __init__(self,
                 active_flow_export_timeout=None,
                 collector=None,
                 observation_domain_id=None,
                 priority=None,
                 template_parameters=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='IpfixDfwConfig',
                 tags=None,
                 applied_tos=None,
                ):
        """
        :type  active_flow_export_timeout: :class:`long` or ``None``
        :param active_flow_export_timeout: For long standing active flows, IPFIX records will be sent per
            timeout period format: int64
        :type  collector: :class:`str` or ``None``
        :param collector: Each IPFIX DFW config can have its own collector config.
        :type  observation_domain_id: :class:`long` or ``None``
        :param observation_domain_id: An identifier that is unique to the exporting process and used to
            meter the Flows. format: int64
        :type  priority: :class:`long` or ``None``
        :param priority: This priority field is used to resolve conflicts in Logical Ports
            which are covered by more than one IPFIX profiles. The IPFIX
            exporter will send records to Collectors in highest priority
            profile (lowest number) only. format: int64
        :type  template_parameters: :class:`IpfixDfwTemplateParameters` or ``None``
        :param template_parameters: An object that indicates whether each corresponding template
            parameter is required or not.
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`IpfixConfig.RESOURCE_TYPE_IPFIXSWITCHCONFIG`
            * :attr:`IpfixConfig.RESOURCE_TYPE_IPFIXDFWCONFIG`
            
             Supported IPFIX Config Types.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  applied_tos: :class:`list` of :class:`ResourceReference` or ``None``
        :param applied_tos: List of objects where the IPFIX Config will be enabled.
        """
        self.active_flow_export_timeout = active_flow_export_timeout
        self.collector = collector
        self.observation_domain_id = observation_domain_id
        self.priority = priority
        self.template_parameters = template_parameters
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        self.applied_tos = applied_tos
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

IpfixDfwConfig._set_binding_type(type.StructType(
    'com.vmware.nsx.model.ipfix_dfw_config', {
        'active_flow_export_timeout': type.OptionalType(type.IntegerType()),
        'collector': type.OptionalType(type.StringType()),
        'observation_domain_id': type.OptionalType(type.IntegerType()),
        'priority': type.OptionalType(type.IntegerType()),
        'template_parameters': type.OptionalType(type.ReferenceType(__name__, 'IpfixDfwTemplateParameters')),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'applied_tos': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceReference'))),
    },
    IpfixDfwConfig,
    False,
    None))



class IpfixDfwTemplateParameters(VapiStruct):
    """
    This entity represents the flow parameters which are exported.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'destination_address': 'destination_address',
                            'destination_transport_port': 'destination_transport_port',
                            'firewall_event': 'firewall_event',
                            'flow_direction': 'flow_direction',
                            'flow_end': 'flow_end',
                            'flow_start': 'flow_start',
                            'icmp_code': 'icmp_code',
                            'octet_delta_count': 'octet_delta_count',
                            'packet_delta_count': 'packet_delta_count',
                            'protocol_identifier': 'protocol_identifier',
                            'rule_id': 'rule_id',
                            'source_address': 'source_address',
                            'source_icmp_type': 'source_icmp_type',
                            'source_transport_port': 'source_transport_port',
                            'vif_uuid': 'vif_uuid',
                            }

    def __init__(self,
                 destination_address=None,
                 destination_transport_port=None,
                 firewall_event=None,
                 flow_direction=None,
                 flow_end=None,
                 flow_start=None,
                 icmp_code=None,
                 octet_delta_count=None,
                 packet_delta_count=None,
                 protocol_identifier=None,
                 rule_id=None,
                 source_address=None,
                 source_icmp_type=None,
                 source_transport_port=None,
                 vif_uuid=None,
                ):
        """
        :type  destination_address: :class:`bool` or ``None``
        :param destination_address: The destination IP address of a monitored network flow.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  destination_transport_port: :class:`bool` or ``None``
        :param destination_transport_port: The destination transport port of a monitored network flow.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  firewall_event: :class:`bool` or ``None``
        :param firewall_event: Five valid values are allowed: 1. Flow Created. 2. Flow Deleted. 3.
            Flow Denied. 4. Flow Alert (not used in DropKick implementation).
            5. Flow Update.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  flow_direction: :class:`bool` or ``None``
        :param flow_direction: Two valid values are allowed: 1. 0x00: igress flow to VM. 2. 0x01:
            egress flow from VM.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  flow_end: :class:`bool` or ``None``
        :param flow_end: The absolute timestamp (seconds) of the last packet of this flow.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  flow_start: :class:`bool` or ``None``
        :param flow_start: The absolute timestamp (seconds) of the first packet of this flow.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  icmp_code: :class:`bool` or ``None``
        :param icmp_code: Code of the IPv4 ICMP message.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  octet_delta_count: :class:`bool` or ``None``
        :param octet_delta_count: The number of octets since the previous report (if any) in incoming
            packets for this flow at the observation point. The number of
            octets include IP header(s) and payload.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  packet_delta_count: :class:`bool` or ``None``
        :param packet_delta_count: The number of incoming packets since the previous report (if any)
            for this flow at the observation point.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protocol_identifier: :class:`bool` or ``None``
        :param protocol_identifier: The value of the protocol number in the IP packet header.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  rule_id: :class:`bool` or ``None``
        :param rule_id: Firewall rule Id - enterprise specific Information Element that
            uniquely identifies firewall rule.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  source_address: :class:`bool` or ``None``
        :param source_address: The source IP address of a monitored network flow.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  source_icmp_type: :class:`bool` or ``None``
        :param source_icmp_type: Type of the IPv4 ICMP message.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  source_transport_port: :class:`bool` or ``None``
        :param source_transport_port: The source transport port of a monitored network flow.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  vif_uuid: :class:`bool` or ``None``
        :param vif_uuid: VIF UUID - enterprise specific Information Element that uniquely
            identifies VIF.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.destination_address = destination_address
        self.destination_transport_port = destination_transport_port
        self.firewall_event = firewall_event
        self.flow_direction = flow_direction
        self.flow_end = flow_end
        self.flow_start = flow_start
        self.icmp_code = icmp_code
        self.octet_delta_count = octet_delta_count
        self.packet_delta_count = packet_delta_count
        self.protocol_identifier = protocol_identifier
        self.rule_id = rule_id
        self.source_address = source_address
        self.source_icmp_type = source_icmp_type
        self.source_transport_port = source_transport_port
        self.vif_uuid = vif_uuid
        VapiStruct.__init__(self)


IpfixDfwTemplateParameters._set_binding_type(type.StructType(
    'com.vmware.nsx.model.ipfix_dfw_template_parameters', {
        'destination_address': type.OptionalType(type.BooleanType()),
        'destination_transport_port': type.OptionalType(type.BooleanType()),
        'firewall_event': type.OptionalType(type.BooleanType()),
        'flow_direction': type.OptionalType(type.BooleanType()),
        'flow_end': type.OptionalType(type.BooleanType()),
        'flow_start': type.OptionalType(type.BooleanType()),
        'icmp_code': type.OptionalType(type.BooleanType()),
        'octet_delta_count': type.OptionalType(type.BooleanType()),
        'packet_delta_count': type.OptionalType(type.BooleanType()),
        'protocol_identifier': type.OptionalType(type.BooleanType()),
        'rule_id': type.OptionalType(type.BooleanType()),
        'source_address': type.OptionalType(type.BooleanType()),
        'source_icmp_type': type.OptionalType(type.BooleanType()),
        'source_transport_port': type.OptionalType(type.BooleanType()),
        'vif_uuid': type.OptionalType(type.BooleanType()),
    },
    IpfixDfwTemplateParameters,
    False,
    None))



class IpfixObsPointConfig(VapiStruct):
    """
    IpfixObsPointConfig (i.e. global switch IPFIX config) is deprecated. Please
    use IpfixSwitchUpmProfile & IpfixCollectorUpmProfile instead. With them,
    switch IPFIX profile can be applied to specific entities, such as logical
    switch, logical port and so on.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'active_timeout': 'active_timeout',
                            'collectors': 'collectors',
                            'enabled': 'enabled',
                            'idle_timeout': 'idle_timeout',
                            'max_flows': 'max_flows',
                            'observation_domain_id': 'observation_domain_id',
                            'packet_sample_probability': 'packet_sample_probability',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 active_timeout=None,
                 collectors=None,
                 enabled=None,
                 idle_timeout=None,
                 max_flows=None,
                 observation_domain_id=None,
                 packet_sample_probability=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  active_timeout: :class:`long` or ``None``
        :param active_timeout: The time in seconds after a Flow is expired even if more packets
            matching this Flow are received by the cache. format: int32
        :type  collectors: :class:`list` of :class:`IpfixCollector` or ``None``
        :param collectors: List of IPFIX collectors
        :type  enabled: :class:`bool` or ``None``
        :param enabled: Enabled status of IPFIX export
        :type  idle_timeout: :class:`long` or ``None``
        :param idle_timeout: The time in seconds after a Flow is expired if no more packets
            matching this Flow are received by the cache. format: int32
        :type  max_flows: :class:`long` or ``None``
        :param max_flows: The maximum number of flow entries in each exporter flow cache.
            format: int64
        :type  observation_domain_id: :class:`long` or ``None``
        :param observation_domain_id: An identifier that is unique to the exporting process and used to
            meter the Flows. format: int64
        :type  packet_sample_probability: :class:`float` or ``None``
        :param packet_sample_probability: The probability in percentage that a packet is sampled. The value
            should be in range (0,100] and can only have three decimal places
            at most. The probability is equal for every packet.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.active_timeout = active_timeout
        self.collectors = collectors
        self.enabled = enabled
        self.idle_timeout = idle_timeout
        self.max_flows = max_flows
        self.observation_domain_id = observation_domain_id
        self.packet_sample_probability = packet_sample_probability
        VapiStruct.__init__(self)


IpfixObsPointConfig._set_binding_type(type.StructType(
    'com.vmware.nsx.model.ipfix_obs_point_config', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'active_timeout': type.OptionalType(type.IntegerType()),
        'collectors': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IpfixCollector'))),
        'enabled': type.OptionalType(type.BooleanType()),
        'idle_timeout': type.OptionalType(type.IntegerType()),
        'max_flows': type.OptionalType(type.IntegerType()),
        'observation_domain_id': type.OptionalType(type.IntegerType()),
        'packet_sample_probability': type.OptionalType(type.DoubleType()),
    },
    IpfixObsPointConfig,
    False,
    None))



class IpfixObsPointsListResult(VapiStruct):
    """
    This is deprecated. Please use UpmProfileListResult instead.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`IpfixObsPointConfig` or ``None``
        :param results: IPFIX observation points
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


IpfixObsPointsListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.ipfix_obs_points_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IpfixObsPointConfig'))),
    },
    IpfixObsPointsListResult,
    False,
    None))



class IpfixServiceAssociationListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "IpfixServiceAssociationListResult"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'results': 'results',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'service_type': 'service_type',
                            }

    def __init__(self,
                 results=None,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 service_type='IpfixServiceAssociationListResult',
                ):
        """
        :type  results: :class:`list` of :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param results: Ipfix config list result with pagination support.
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`IpfixConfig`. When methods return a value of this class as
            a return value, the attribute will contain all the attributes
            defined in :class:`IpfixConfig`.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  service_type: :class:`str`
        :param service_type: Possible values are: 
            
            *
              :attr:`ServiceAssociationListResult.SERVICE_TYPE_FIREWALLSERVICEASSOCIATIONLISTRESULT`
            *
              :attr:`ServiceAssociationListResult.SERVICE_TYPE_IPFIXSERVICEASSOCIATIONLISTRESULT`
        """
        self.results = results
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self._service_type = service_type
        VapiStruct.__init__(self)

    @property
    def service_type(self):
        """
        Return the discriminator value
        """
        return self._service_type

IpfixServiceAssociationListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.ipfix_service_association_list_result', {
        'results': type.OptionalType(type.ListType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'IpfixConfig')]))),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'service_type': type.StringType(),
    },
    IpfixServiceAssociationListResult,
    False,
    None))



class IpfixSwitchConfig(VapiStruct):
    """
    This is deprecated. Please use IpfixSwitchUpmProfile instead which can
    specify its own collectors and observation ID.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "IpfixSwitchConfig"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'active_timeout': 'active_timeout',
                            'idle_timeout': 'idle_timeout',
                            'max_flows': 'max_flows',
                            'packet_sample_probability': 'packet_sample_probability',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'applied_tos': 'applied_tos',
                            }

    def __init__(self,
                 active_timeout=None,
                 idle_timeout=None,
                 max_flows=None,
                 packet_sample_probability=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='IpfixSwitchConfig',
                 tags=None,
                 applied_tos=None,
                ):
        """
        :type  active_timeout: :class:`long` or ``None``
        :param active_timeout: The time in seconds after a Flow is expired even if more packets
            matching this Flow are received by the cache. format: int32
        :type  idle_timeout: :class:`long` or ``None``
        :param idle_timeout: The time in seconds after a Flow is expired if no more packets
            matching this Flow are received by the cache. format: int32
        :type  max_flows: :class:`long` or ``None``
        :param max_flows: The maximum number of flow entries in each exporter flow cache.
            format: int64
        :type  packet_sample_probability: :class:`float` or ``None``
        :param packet_sample_probability: The probability in percentage that a packet is sampled. The value
            should be in range (0,100] and can only have three decimal places
            at most. The probability is equal for every packet.
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`IpfixConfig.RESOURCE_TYPE_IPFIXSWITCHCONFIG`
            * :attr:`IpfixConfig.RESOURCE_TYPE_IPFIXDFWCONFIG`
            
             Supported IPFIX Config Types.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  applied_tos: :class:`list` of :class:`ResourceReference` or ``None``
        :param applied_tos: List of objects where the IPFIX Config will be enabled.
        """
        self.active_timeout = active_timeout
        self.idle_timeout = idle_timeout
        self.max_flows = max_flows
        self.packet_sample_probability = packet_sample_probability
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        self.applied_tos = applied_tos
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

IpfixSwitchConfig._set_binding_type(type.StructType(
    'com.vmware.nsx.model.ipfix_switch_config', {
        'active_timeout': type.OptionalType(type.IntegerType()),
        'idle_timeout': type.OptionalType(type.IntegerType()),
        'max_flows': type.OptionalType(type.IntegerType()),
        'packet_sample_probability': type.OptionalType(type.DoubleType()),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'applied_tos': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceReference'))),
    },
    IpfixSwitchConfig,
    False,
    None))



class IpfixSwitchUpmProfile(VapiStruct):
    """
    The configuration for Internet protocol flow information export (IPFIX) and
    would be enabled on the switching module to collect flow information.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "IpfixSwitchUpmProfile"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'active_timeout': 'active_timeout',
                            'applied_tos': 'applied_tos',
                            'collector_profile': 'collector_profile',
                            'export_overlay_flow': 'export_overlay_flow',
                            'idle_timeout': 'idle_timeout',
                            'max_flows': 'max_flows',
                            'observation_domain_id': 'observation_domain_id',
                            'packet_sample_probability': 'packet_sample_probability',
                            'priority': 'priority',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            }

    def __init__(self,
                 active_timeout=None,
                 applied_tos=None,
                 collector_profile=None,
                 export_overlay_flow=None,
                 idle_timeout=None,
                 max_flows=None,
                 observation_domain_id=None,
                 packet_sample_probability=None,
                 priority=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='IpfixSwitchUpmProfile',
                 tags=None,
                ):
        """
        :type  active_timeout: :class:`long` or ``None``
        :param active_timeout: The time in seconds after a flow is expired even if more packets
            matching this Flow are received by the cache. format: int32
        :type  applied_tos: :class:`AppliedTos` or ``None``
        :param applied_tos: Entities where the IPFIX profile will be enabled on. Maximum entity
            count of all types is 128.
        :type  collector_profile: :class:`str` or ``None``
        :param collector_profile: Each IPFIX switching profile can have its own collector profile.
        :type  export_overlay_flow: :class:`bool` or ``None``
        :param export_overlay_flow: It controls whether sample result includes overlay flow info.
        :type  idle_timeout: :class:`long` or ``None``
        :param idle_timeout: The time in seconds after a flow is expired if no more packets
            matching this flow are received by the cache. format: int32
        :type  max_flows: :class:`long` or ``None``
        :param max_flows: The maximum number of flow entries in each exporter flow cache.
            format: int64
        :type  observation_domain_id: :class:`long` or ``None``
        :param observation_domain_id: An identifier that is unique to the exporting process and used to
            meter the Flows. format: int64
        :type  packet_sample_probability: :class:`float` or ``None``
        :param packet_sample_probability: The probability in percentage that a packet is sampled. The value
            should be in range (0,100] and can only have three decimal places
            at most. The probability is equal for every packet.
        :type  priority: :class:`long` or ``None``
        :param priority: This priority field is used to resolve conflicts in logical
            ports/switch which inherit multiple switch IPFIX profiles from
            NSGroups. Override rule is : for multiple profiles inherited from
            NSGroups, the one with highest priority (lowest number) overrides
            others; the profile directly applied to logical switch overrides
            profiles inherited from NSGroup; the profile directly applied to
            logical port overides profiles inherited from logical switch and/or
            nsgroup; The IPFIX exporter will send records to collectors of
            final effective profile only. format: int32
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`IpfixUpmProfile.RESOURCE_TYPE_IPFIXSWITCHUPMPROFILE`
            
             All IPFIX profile types.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        """
        self.active_timeout = active_timeout
        self.applied_tos = applied_tos
        self.collector_profile = collector_profile
        self.export_overlay_flow = export_overlay_flow
        self.idle_timeout = idle_timeout
        self.max_flows = max_flows
        self.observation_domain_id = observation_domain_id
        self.packet_sample_probability = packet_sample_probability
        self.priority = priority
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

IpfixSwitchUpmProfile._set_binding_type(type.StructType(
    'com.vmware.nsx.model.ipfix_switch_upm_profile', {
        'active_timeout': type.OptionalType(type.IntegerType()),
        'applied_tos': type.OptionalType(type.ReferenceType(__name__, 'AppliedTos')),
        'collector_profile': type.OptionalType(type.StringType()),
        'export_overlay_flow': type.OptionalType(type.BooleanType()),
        'idle_timeout': type.OptionalType(type.IntegerType()),
        'max_flows': type.OptionalType(type.IntegerType()),
        'observation_domain_id': type.OptionalType(type.IntegerType()),
        'packet_sample_probability': type.OptionalType(type.DoubleType()),
        'priority': type.OptionalType(type.IntegerType()),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
    },
    IpfixSwitchUpmProfile,
    False,
    None))



class IpfixUpmProfile(VapiStruct):
    """
    Parent profile of all IPFIX profiles.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "IpfixUpmProfile"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    RESOURCE_TYPE_IPFIXSWITCHUPMPROFILE = "IpfixSwitchUpmProfile"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='IpfixUpmProfile',
                 tags=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`IpfixUpmProfile.RESOURCE_TYPE_IPFIXSWITCHUPMPROFILE`
            
             All IPFIX profile types.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

IpfixUpmProfile._set_binding_type(type.StructType(
    'com.vmware.nsx.model.ipfix_upm_profile', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
    },
    IpfixUpmProfile,
    False,
    None))



class IpfixUpmProfileListResult(VapiStruct):
    """
    IPFIX profile list result for query with list parameters

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param results: IPFIX Profile List
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`IpfixUpmProfile`. When methods return a value of this class
            as a return value, the attribute will contain all the attributes
            defined in :class:`IpfixUpmProfile`.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


IpfixUpmProfileListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.ipfix_upm_profile_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'IpfixUpmProfile')]))),
    },
    IpfixUpmProfileListResult,
    False,
    None))



class Ipv4Header(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'dst_ip': 'dst_ip',
                            'flags': 'flags',
                            'protocol': 'protocol',
                            'src_ip': 'src_ip',
                            'src_subnet_prefix_len': 'src_subnet_prefix_len',
                            'ttl': 'ttl',
                            }

    def __init__(self,
                 dst_ip=None,
                 flags=None,
                 protocol=None,
                 src_ip=None,
                 src_subnet_prefix_len=None,
                 ttl=None,
                ):
        """
        :type  dst_ip: :class:`str` or ``None``
        :param dst_ip: The destination ip address. format: ipv4
        :type  flags: :class:`long` or ``None``
        :param flags: IP flags format: int64
        :type  protocol: :class:`long` or ``None``
        :param protocol: IP protocol - defaults to ICMP format: int64
        :type  src_ip: :class:`str` or ``None``
        :param src_ip: The source ip address. format: ipv4
        :type  src_subnet_prefix_len: :class:`long` or ``None``
        :param src_subnet_prefix_len: This is used together with src_ip to calculate dst_ip for broadcast
            when dst_ip is not given; not used in all other cases. format:
            int64
        :type  ttl: :class:`long` or ``None``
        :param ttl: Time to live (ttl) format: int64
        """
        self.dst_ip = dst_ip
        self.flags = flags
        self.protocol = protocol
        self.src_ip = src_ip
        self.src_subnet_prefix_len = src_subnet_prefix_len
        self.ttl = ttl
        VapiStruct.__init__(self)


Ipv4Header._set_binding_type(type.StructType(
    'com.vmware.nsx.model.ipv4_header', {
        'dst_ip': type.OptionalType(type.StringType()),
        'flags': type.OptionalType(type.IntegerType()),
        'protocol': type.OptionalType(type.IntegerType()),
        'src_ip': type.OptionalType(type.StringType()),
        'src_subnet_prefix_len': type.OptionalType(type.IntegerType()),
        'ttl': type.OptionalType(type.IntegerType()),
    },
    Ipv4Header,
    False,
    None))



class Ipv6Header(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'dst_ip': 'dst_ip',
                            'hop_limit': 'hop_limit',
                            'next_header': 'next_header',
                            'src_ip': 'src_ip',
                            }

    def __init__(self,
                 dst_ip=None,
                 hop_limit=None,
                 next_header=None,
                 src_ip=None,
                ):
        """
        :type  dst_ip: :class:`str` or ``None``
        :param dst_ip: The destination ip address. format: ipv6
        :type  hop_limit: :class:`long` or ``None``
        :param hop_limit: Decremented by 1 by each node that forwards the packets. The packet
            is discarded if Hop Limit is decremented to zero. format: int64
        :type  next_header: :class:`long` or ``None``
        :param next_header: Identifies the type of header immediately following the IPv6
            header. format: int64
        :type  src_ip: :class:`str` or ``None``
        :param src_ip: The source ip address. format: ipv6
        """
        self.dst_ip = dst_ip
        self.hop_limit = hop_limit
        self.next_header = next_header
        self.src_ip = src_ip
        VapiStruct.__init__(self)


Ipv6Header._set_binding_type(type.StructType(
    'com.vmware.nsx.model.ipv6_header', {
        'dst_ip': type.OptionalType(type.StringType()),
        'hop_limit': type.OptionalType(type.IntegerType()),
        'next_header': type.OptionalType(type.IntegerType()),
        'src_ip': type.OptionalType(type.StringType()),
    },
    Ipv6Header,
    False,
    None))



class JoinClusterParameters(VapiStruct):
    """
    To join a new node to the NSX cluster, issue a JoinCluster API on the new
    node. The JoinCluster API takes this object as a parameter. Provide the ID
    of the NSX cluster you want the new node to join and the IP address of one
    of the nodes already in that cluster. The Cluster Boot Manager running on
    the new node will then add the new node to the NSX cluster by making a
    AttachClusterNode REST API call on the node that is already part of the
    cluster. In order to make a REST API call to the node in the cluster, the
    Cluster Boot Manager will need username and password of a priviledged user
    on the node in the cluster. In place of a username and password, Cluster
    Boot Manager could also use a OAuth token provided. The Cluster Boot
    Manager needs either the username and password or the OAuth token to make
    the REST call but not both.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'certficate_sha256_thumbprint': 'certficate_sha256_thumbprint',
                            'cluster_id': 'cluster_id',
                            'ip_address': 'ip_address',
                            'password': 'password',
                            'port': 'port',
                            'token': 'token',
                            'username': 'username',
                            }

    def __init__(self,
                 certficate_sha256_thumbprint=None,
                 cluster_id=None,
                 ip_address=None,
                 password=None,
                 port=None,
                 token=None,
                 username=None,
                ):
        """
        :type  certficate_sha256_thumbprint: :class:`str` or ``None``
        :param certficate_sha256_thumbprint: SHA256 Thumbprint of the API certificate of the cluster node
        :type  cluster_id: :class:`str` or ``None``
        :param cluster_id: UUID of the cluster to join
        :type  ip_address: :class:`str` or ``None``
        :param ip_address: IP address of a node already part of the cluster to join
        :type  password: :class:`str` or ``None``
        :param password: Password of the user on the cluster node
        :type  port: :class:`long` or ``None``
        :param port: API port on the cluster node format: int64
        :type  token: :class:`str` or ``None``
        :param token: Limited time OAuth token instead of the username/password
        :type  username: :class:`str` or ``None``
        :param username: Username on the cluster node
        """
        self.certficate_sha256_thumbprint = certficate_sha256_thumbprint
        self.cluster_id = cluster_id
        self.ip_address = ip_address
        self.password = password
        self.port = port
        self.token = token
        self.username = username
        VapiStruct.__init__(self)


JoinClusterParameters._set_binding_type(type.StructType(
    'com.vmware.nsx.model.join_cluster_parameters', {
        'certficate_sha256_thumbprint': type.OptionalType(type.StringType()),
        'cluster_id': type.OptionalType(type.StringType()),
        'ip_address': type.OptionalType(type.StringType()),
        'password': type.OptionalType(type.StringType()),
        'port': type.OptionalType(type.IntegerType()),
        'token': type.OptionalType(type.StringType()),
        'username': type.OptionalType(type.StringType()),
    },
    JoinClusterParameters,
    False,
    None))



class KeyValue(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'key': 'key',
                            'value': 'value',
                            }

    def __init__(self,
                 key=None,
                 value=None,
                ):
        """
        :type  key: :class:`str` or ``None``
        :param key: Key name.
        :type  value: :class:`str` or ``None``
        :param value: Key value.
        """
        self.key = key
        self.value = value
        VapiStruct.__init__(self)


KeyValue._set_binding_type(type.StructType(
    'com.vmware.nsx.model.key_value', {
        'key': type.OptionalType(type.StringType()),
        'value': type.OptionalType(type.StringType()),
    },
    KeyValue,
    False,
    None))



class KeyValuePair(VapiStruct):
    """
    An arbitrary key-value pair

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'key': 'key',
                            'value': 'value',
                            }

    def __init__(self,
                 key=None,
                 value=None,
                ):
        """
        :type  key: :class:`str` or ``None``
        :param key: Key
        :type  value: :class:`str` or ``None``
        :param value: Value
        """
        self.key = key
        self.value = value
        VapiStruct.__init__(self)


KeyValuePair._set_binding_type(type.StructType(
    'com.vmware.nsx.model.key_value_pair', {
        'key': type.OptionalType(type.StringType()),
        'value': type.OptionalType(type.StringType()),
    },
    KeyValuePair,
    False,
    None))



class KnownHostParameter(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'host': 'host',
                            'port': 'port',
                            }

    def __init__(self,
                 host=None,
                 port=None,
                ):
        """
        :type  host: :class:`str` or ``None``
        :param host: Known host hostname or IP address format: hostname-or-ipv4
        :type  port: :class:`long` or ``None``
        :param port: Known host port format: int64
        """
        self.host = host
        self.port = port
        VapiStruct.__init__(self)


KnownHostParameter._set_binding_type(type.StructType(
    'com.vmware.nsx.model.known_host_parameter', {
        'host': type.OptionalType(type.StringType()),
        'port': type.OptionalType(type.IntegerType()),
    },
    KnownHostParameter,
    False,
    None))



class L2ForwarderRemoteMacs(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'inter_site_forwarder_status': 'inter_site_forwarder_status',
                            'last_update_timestamp': 'last_update_timestamp',
                            'logical_switch_id': 'logical_switch_id',
                            'remote_macs_per_site': 'remote_macs_per_site',
                            }

    def __init__(self,
                 inter_site_forwarder_status=None,
                 last_update_timestamp=None,
                 logical_switch_id=None,
                 remote_macs_per_site=None,
                ):
        """
        :type  inter_site_forwarder_status: :class:`list` of :class:`L2ForwarderStatusPerNode` or ``None``
        :param inter_site_forwarder_status: Inter-site forwarder status per node.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_update_timestamp: :class:`long` or ``None``
        :param last_update_timestamp: Timestamp when the l2 forwarder remote mac addresses was last
            updated. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  logical_switch_id: :class:`str` or ``None``
        :param logical_switch_id: Logical switch id on which the L2 forwarder is created.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  remote_macs_per_site: :class:`list` of :class:`L2ForwarderRemoteMacsPerSite` or ``None``
        :param remote_macs_per_site: L2 forwarder remote mac addresses per site for logical switch.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.inter_site_forwarder_status = inter_site_forwarder_status
        self.last_update_timestamp = last_update_timestamp
        self.logical_switch_id = logical_switch_id
        self.remote_macs_per_site = remote_macs_per_site
        VapiStruct.__init__(self)


L2ForwarderRemoteMacs._set_binding_type(type.StructType(
    'com.vmware.nsx.model.l2_forwarder_remote_macs', {
        'inter_site_forwarder_status': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'L2ForwarderStatusPerNode'))),
        'last_update_timestamp': type.OptionalType(type.IntegerType()),
        'logical_switch_id': type.OptionalType(type.StringType()),
        'remote_macs_per_site': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'L2ForwarderRemoteMacsPerSite'))),
    },
    L2ForwarderRemoteMacs,
    False,
    None))



class L2ForwarderRemoteMacsPerSite(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'remote_active_ips': 'remote_active_ips',
                            'remote_mac_addresses': 'remote_mac_addresses',
                            'remote_site': 'remote_site',
                            'remote_standby_ips': 'remote_standby_ips',
                            'rtep_group_id': 'rtep_group_id',
                            }

    def __init__(self,
                 remote_active_ips=None,
                 remote_mac_addresses=None,
                 remote_site=None,
                 remote_standby_ips=None,
                 rtep_group_id=None,
                ):
        """
        :type  remote_active_ips: :class:`list` of :class:`str` or ``None``
        :param remote_active_ips: Remote active IP addresses. format: ip
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  remote_mac_addresses: :class:`list` of :class:`str` or ``None``
        :param remote_mac_addresses: Remote mac addresses.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  remote_site: :class:`ResourceReference` or ``None``
        :param remote_site: Remote site details.
        :type  remote_standby_ips: :class:`list` of :class:`str` or ``None``
        :param remote_standby_ips: Remote standby IP addresses. format: ip
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  rtep_group_id: :class:`long` or ``None``
        :param rtep_group_id: 32 bit unique RTEP group id of the logical switch per site. format:
            int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.remote_active_ips = remote_active_ips
        self.remote_mac_addresses = remote_mac_addresses
        self.remote_site = remote_site
        self.remote_standby_ips = remote_standby_ips
        self.rtep_group_id = rtep_group_id
        VapiStruct.__init__(self)


L2ForwarderRemoteMacsPerSite._set_binding_type(type.StructType(
    'com.vmware.nsx.model.l2_forwarder_remote_macs_per_site', {
        'remote_active_ips': type.OptionalType(type.ListType(type.StringType())),
        'remote_mac_addresses': type.OptionalType(type.ListType(type.StringType())),
        'remote_site': type.OptionalType(type.ReferenceType(__name__, 'ResourceReference')),
        'remote_standby_ips': type.OptionalType(type.ListType(type.StringType())),
        'rtep_group_id': type.OptionalType(type.IntegerType()),
    },
    L2ForwarderRemoteMacsPerSite,
    False,
    None))



class L2ForwarderStatistics(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'last_update_timestamp': 'last_update_timestamp',
                            'logical_switch_id': 'logical_switch_id',
                            'rx': 'rx',
                            'tx': 'tx',
                            }

    def __init__(self,
                 last_update_timestamp=None,
                 logical_switch_id=None,
                 rx=None,
                 tx=None,
                ):
        """
        :type  last_update_timestamp: :class:`long` or ``None``
        :param last_update_timestamp: Timestamp when the l2 forwarder statistics was last updated.
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  logical_switch_id: :class:`str` or ``None``
        :param logical_switch_id: Logical switch id on which the L2 forwarder is created.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  rx: :class:`InterSitePortCounters` or ``None``
        :param rx: Total received data counters.
        :type  tx: :class:`InterSitePortCounters` or ``None``
        :param tx: Total sent data counters.
        """
        self.last_update_timestamp = last_update_timestamp
        self.logical_switch_id = logical_switch_id
        self.rx = rx
        self.tx = tx
        VapiStruct.__init__(self)


L2ForwarderStatistics._set_binding_type(type.StructType(
    'com.vmware.nsx.model.l2_forwarder_statistics', {
        'last_update_timestamp': type.OptionalType(type.IntegerType()),
        'logical_switch_id': type.OptionalType(type.StringType()),
        'rx': type.OptionalType(type.ReferenceType(__name__, 'InterSitePortCounters')),
        'tx': type.OptionalType(type.ReferenceType(__name__, 'InterSitePortCounters')),
    },
    L2ForwarderStatistics,
    False,
    None))



class L2ForwarderStatus(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'last_update_timestamp': 'last_update_timestamp',
                            'logical_switch_id': 'logical_switch_id',
                            'status_per_node': 'status_per_node',
                            }

    def __init__(self,
                 last_update_timestamp=None,
                 logical_switch_id=None,
                 status_per_node=None,
                ):
        """
        :type  last_update_timestamp: :class:`long` or ``None``
        :param last_update_timestamp: Timestamp when the service router status was last updated. format:
            int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  logical_switch_id: :class:`str` or ``None``
        :param logical_switch_id: Logical switch id on which the L2 forwarder is created.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  status_per_node: :class:`list` of :class:`L2ForwarderStatusPerNode` or ``None``
        :param status_per_node: L2 forwarder status per node.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.last_update_timestamp = last_update_timestamp
        self.logical_switch_id = logical_switch_id
        self.status_per_node = status_per_node
        VapiStruct.__init__(self)


L2ForwarderStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.l2_forwarder_status', {
        'last_update_timestamp': type.OptionalType(type.IntegerType()),
        'logical_switch_id': type.OptionalType(type.StringType()),
        'status_per_node': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'L2ForwarderStatusPerNode'))),
    },
    L2ForwarderStatus,
    False,
    None))



class L2ForwarderStatusPerNode(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    HIGH_AVAILABILITY_STATUS_ACTIVE = "ACTIVE"
    """


    """
    HIGH_AVAILABILITY_STATUS_STANDBY = "STANDBY"
    """


    """
    HIGH_AVAILABILITY_STATUS_DOWN = "DOWN"
    """


    """
    HIGH_AVAILABILITY_STATUS_SYNC = "SYNC"
    """


    """
    HIGH_AVAILABILITY_STATUS_UNKNOWN = "UNKNOWN"
    """


    """



    _canonical_to_pep_names = {
                            'high_availability_status': 'high_availability_status',
                            'transport_node': 'transport_node',
                            }

    def __init__(self,
                 high_availability_status=None,
                 transport_node=None,
                ):
        """
        :type  high_availability_status: :class:`str` or ``None``
        :param high_availability_status: Possible values are: 
            
            * :attr:`L2ForwarderStatusPerNode.HIGH_AVAILABILITY_STATUS_ACTIVE`
            * :attr:`L2ForwarderStatusPerNode.HIGH_AVAILABILITY_STATUS_STANDBY`
            * :attr:`L2ForwarderStatusPerNode.HIGH_AVAILABILITY_STATUS_DOWN`
            * :attr:`L2ForwarderStatusPerNode.HIGH_AVAILABILITY_STATUS_SYNC`
            * :attr:`L2ForwarderStatusPerNode.HIGH_AVAILABILITY_STATUS_UNKNOWN`
            
             High Availability status of a service router on the edge node.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  transport_node: :class:`ResourceReference` or ``None``
        :param transport_node: Edge node details from where the router status is being retrieved.
        """
        self.high_availability_status = high_availability_status
        self.transport_node = transport_node
        VapiStruct.__init__(self)


L2ForwarderStatusPerNode._set_binding_type(type.StructType(
    'com.vmware.nsx.model.l2_forwarder_status_per_node', {
        'high_availability_status': type.OptionalType(type.StringType()),
        'transport_node': type.OptionalType(type.ReferenceType(__name__, 'ResourceReference')),
    },
    L2ForwarderStatusPerNode,
    False,
    None))



class L2VPNPerLSTrafficStatistics(VapiStruct):
    """
    Traffic statistics for a logical switch.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'bum_bytes_in': 'bum_bytes_in',
                            'bum_bytes_out': 'bum_bytes_out',
                            'bum_packets_in': 'bum_packets_in',
                            'bum_packets_out': 'bum_packets_out',
                            'bytes_in': 'bytes_in',
                            'bytes_out': 'bytes_out',
                            'logical_switch': 'logical_switch',
                            'packets_in': 'packets_in',
                            'packets_out': 'packets_out',
                            'packets_receive_error': 'packets_receive_error',
                            'packets_sent_error': 'packets_sent_error',
                            }

    def __init__(self,
                 bum_bytes_in=None,
                 bum_bytes_out=None,
                 bum_packets_in=None,
                 bum_packets_out=None,
                 bytes_in=None,
                 bytes_out=None,
                 logical_switch=None,
                 packets_in=None,
                 packets_out=None,
                 packets_receive_error=None,
                 packets_sent_error=None,
                ):
        """
        :type  bum_bytes_in: :class:`long` or ``None``
        :param bum_bytes_in: Total number of incoming Broadcast, Unknown unicast and Multicast
            (BUM) bytes. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  bum_bytes_out: :class:`long` or ``None``
        :param bum_bytes_out: Total number of outgoing Broadcast, Unknown unicast and Multicast
            (BUM) bytes. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  bum_packets_in: :class:`long` or ``None``
        :param bum_packets_in: Total number of incoming Broadcast, Unknown unicast and Multicast
            (BUM) packets. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  bum_packets_out: :class:`long` or ``None``
        :param bum_packets_out: Total number of outgoing Broadcast, Unknown unicast and Multicast
            (BUM) packets. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  bytes_in: :class:`long` or ``None``
        :param bytes_in: Total number of incoming bytes. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  bytes_out: :class:`long` or ``None``
        :param bytes_out: Total number of outgoing bytes. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  logical_switch: :class:`ResourceReference` or ``None``
        :param logical_switch: Logical switch
        :type  packets_in: :class:`long` or ``None``
        :param packets_in: Total number of incoming packets. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  packets_out: :class:`long` or ``None``
        :param packets_out: Total number of outgoing packets. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  packets_receive_error: :class:`long` or ``None``
        :param packets_receive_error: Total number of incoming packets dropped. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  packets_sent_error: :class:`long` or ``None``
        :param packets_sent_error: Total number of packets dropped while sending for any reason.
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.bum_bytes_in = bum_bytes_in
        self.bum_bytes_out = bum_bytes_out
        self.bum_packets_in = bum_packets_in
        self.bum_packets_out = bum_packets_out
        self.bytes_in = bytes_in
        self.bytes_out = bytes_out
        self.logical_switch = logical_switch
        self.packets_in = packets_in
        self.packets_out = packets_out
        self.packets_receive_error = packets_receive_error
        self.packets_sent_error = packets_sent_error
        VapiStruct.__init__(self)


L2VPNPerLSTrafficStatistics._set_binding_type(type.StructType(
    'com.vmware.nsx.model.l2_VPN_per_LS_traffic_statistics', {
        'bum_bytes_in': type.OptionalType(type.IntegerType()),
        'bum_bytes_out': type.OptionalType(type.IntegerType()),
        'bum_packets_in': type.OptionalType(type.IntegerType()),
        'bum_packets_out': type.OptionalType(type.IntegerType()),
        'bytes_in': type.OptionalType(type.IntegerType()),
        'bytes_out': type.OptionalType(type.IntegerType()),
        'logical_switch': type.OptionalType(type.ReferenceType(__name__, 'ResourceReference')),
        'packets_in': type.OptionalType(type.IntegerType()),
        'packets_out': type.OptionalType(type.IntegerType()),
        'packets_receive_error': type.OptionalType(type.IntegerType()),
        'packets_sent_error': type.OptionalType(type.IntegerType()),
    },
    L2VPNPerLSTrafficStatistics,
    False,
    None))



class L2VPNSessionRemoteMacs(VapiStruct):
    """
    Remote MAC addresses for all logical switches for a L2VPN session.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'display_name': 'display_name',
                            'remote_mac_addresses': 'remote_mac_addresses',
                            'session_id': 'session_id',
                            }

    def __init__(self,
                 display_name=None,
                 remote_mac_addresses=None,
                 session_id=None,
                ):
        """
        :type  display_name: :class:`str` or ``None``
        :param display_name: L2VPN display name.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  remote_mac_addresses: :class:`list` of :class:`L2VPNSessionRemoteMacsForLS` or ``None``
        :param remote_mac_addresses: List MAC addresses for all logical switch for a particular L2VPN
            session.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  session_id: :class:`str` or ``None``
        :param session_id: L2VPN session identifier.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.display_name = display_name
        self.remote_mac_addresses = remote_mac_addresses
        self.session_id = session_id
        VapiStruct.__init__(self)


L2VPNSessionRemoteMacs._set_binding_type(type.StructType(
    'com.vmware.nsx.model.l2_VPN_session_remote_macs', {
        'display_name': type.OptionalType(type.StringType()),
        'remote_mac_addresses': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'L2VPNSessionRemoteMacsForLS'))),
        'session_id': type.OptionalType(type.StringType()),
    },
    L2VPNSessionRemoteMacs,
    False,
    None))



class L2VPNSessionRemoteMacsForLS(VapiStruct):
    """
    Remote MAC addresses for logical switch.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'logical_switch': 'logical_switch',
                            'remote_mac_addresses': 'remote_mac_addresses',
                            'tags': 'tags',
                            }

    def __init__(self,
                 logical_switch=None,
                 remote_mac_addresses=None,
                 tags=None,
                ):
        """
        :type  logical_switch: :class:`ResourceReference` or ``None``
        :param logical_switch: Logical switch.
        :type  remote_mac_addresses: :class:`list` of :class:`str` or ``None``
        :param remote_mac_addresses: Mac addresses.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Contains policy specific information like policy path.
        """
        self.logical_switch = logical_switch
        self.remote_mac_addresses = remote_mac_addresses
        self.tags = tags
        VapiStruct.__init__(self)


L2VPNSessionRemoteMacsForLS._set_binding_type(type.StructType(
    'com.vmware.nsx.model.l2_VPN_session_remote_macs_for_LS', {
        'logical_switch': type.OptionalType(type.ReferenceType(__name__, 'ResourceReference')),
        'remote_mac_addresses': type.OptionalType(type.ListType(type.StringType())),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
    },
    L2VPNSessionRemoteMacsForLS,
    False,
    None))



class L2VPNSessionStatistics(VapiStruct):
    """
    Session statistics gives VPN session status and traffic statistics per
    logical switch.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'display_name': 'display_name',
                            'partial_stats': 'partial_stats',
                            'session_id': 'session_id',
                            'tap_traffic_counters': 'tap_traffic_counters',
                            'traffic_statistics_per_logical_switch': 'traffic_statistics_per_logical_switch',
                            }

    def __init__(self,
                 display_name=None,
                 partial_stats=None,
                 session_id=None,
                 tap_traffic_counters=None,
                 traffic_statistics_per_logical_switch=None,
                ):
        """
        :type  display_name: :class:`str` or ``None``
        :param display_name: L2VPN display name.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  partial_stats: :class:`bool` or ``None``
        :param partial_stats: Partial statistics is set to true if onle active node responds
            while standby does not. In case of both nodes responded statistics
            will be summed and partial stats will be false. If cluster has only
            active node, partial statistics will always be false.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  session_id: :class:`str` or ``None``
        :param session_id: Session identifier for L2VPN.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  tap_traffic_counters: :class:`list` of :class:`L2VPNTapTrafficStatistics` or ``None``
        :param tap_traffic_counters: Tunnel port traffic counters.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  traffic_statistics_per_logical_switch: :class:`list` of :class:`L2VPNPerLSTrafficStatistics` or ``None``
        :param traffic_statistics_per_logical_switch: Traffic statistics per logical switch.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.display_name = display_name
        self.partial_stats = partial_stats
        self.session_id = session_id
        self.tap_traffic_counters = tap_traffic_counters
        self.traffic_statistics_per_logical_switch = traffic_statistics_per_logical_switch
        VapiStruct.__init__(self)


L2VPNSessionStatistics._set_binding_type(type.StructType(
    'com.vmware.nsx.model.l2_VPN_session_statistics', {
        'display_name': type.OptionalType(type.StringType()),
        'partial_stats': type.OptionalType(type.BooleanType()),
        'session_id': type.OptionalType(type.StringType()),
        'tap_traffic_counters': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'L2VPNTapTrafficStatistics'))),
        'traffic_statistics_per_logical_switch': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'L2VPNPerLSTrafficStatistics'))),
    },
    L2VPNSessionStatistics,
    False,
    None))



class L2VPNSessionStatus(VapiStruct):
    """
    L2VPN session status.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATUS_UP = "UP"
    """


    """
    STATUS_DOWN = "DOWN"
    """


    """



    _canonical_to_pep_names = {
                            'display_name': 'display_name',
                            'session_id': 'session_id',
                            'status': 'status',
                            'transport_tunnels': 'transport_tunnels',
                            }

    def __init__(self,
                 display_name=None,
                 session_id=None,
                 status=None,
                 transport_tunnels=None,
                ):
        """
        :type  display_name: :class:`str` or ``None``
        :param display_name: L2VPN display name.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  session_id: :class:`str` or ``None``
        :param session_id: L2VPN session identifier.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  status: :class:`str` or ``None``
        :param status: Possible values are: 
            
            * :attr:`L2VPNSessionStatus.STATUS_UP`
            * :attr:`L2VPNSessionStatus.STATUS_DOWN`
            
             L2 VPN session status, specifies UP/DOWN.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  transport_tunnels: :class:`list` of :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param transport_tunnels: Transport tunnels status.
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`L2VPNTransportTunnelStatus`. When methods return a value of
            this class as a return value, the attribute will contain all the
            attributes defined in :class:`L2VPNTransportTunnelStatus`.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.display_name = display_name
        self.session_id = session_id
        self.status = status
        self.transport_tunnels = transport_tunnels
        VapiStruct.__init__(self)


L2VPNSessionStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.l2_VPN_session_status', {
        'display_name': type.OptionalType(type.StringType()),
        'session_id': type.OptionalType(type.StringType()),
        'status': type.OptionalType(type.StringType()),
        'transport_tunnels': type.OptionalType(type.ListType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'L2VPNTransportTunnelStatus')]))),
    },
    L2VPNSessionStatus,
    False,
    None))



class L2VPNSessionSummary(VapiStruct):
    """
    List summary of L2VPN sessions.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'established_l2vpn_sessions': 'established_l2vpn_sessions',
                            'failed_l2vpn_sessions': 'failed_l2vpn_sessions',
                            'total_l2vpn_sessions': 'total_l2vpn_sessions',
                            }

    def __init__(self,
                 established_l2vpn_sessions=None,
                 failed_l2vpn_sessions=None,
                 total_l2vpn_sessions=None,
                ):
        """
        :type  established_l2vpn_sessions: :class:`long` or ``None``
        :param established_l2vpn_sessions: Number of established L2VPN sessions. L2VPN session is established
            when all the tunnels are up. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  failed_l2vpn_sessions: :class:`long` or ``None``
        :param failed_l2vpn_sessions: Number of failed L2VPN sessions. L2VPN session is failed when all
            the tunnels are down. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  total_l2vpn_sessions: :class:`long` or ``None``
        :param total_l2vpn_sessions: Total L2VPN sessions configured. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.established_l2vpn_sessions = established_l2vpn_sessions
        self.failed_l2vpn_sessions = failed_l2vpn_sessions
        self.total_l2vpn_sessions = total_l2vpn_sessions
        VapiStruct.__init__(self)


L2VPNSessionSummary._set_binding_type(type.StructType(
    'com.vmware.nsx.model.l2_VPN_session_summary', {
        'established_l2vpn_sessions': type.OptionalType(type.IntegerType()),
        'failed_l2vpn_sessions': type.OptionalType(type.IntegerType()),
        'total_l2vpn_sessions': type.OptionalType(type.IntegerType()),
    },
    L2VPNSessionSummary,
    False,
    None))



class L2VPNTapTrafficStatistics(VapiStruct):
    """
    TAP (Terminal access point) traffic statistics for L2VPN.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'bytes_in': 'bytes_in',
                            'bytes_out': 'bytes_out',
                            'packets_in': 'packets_in',
                            'packets_out': 'packets_out',
                            'packets_receive_error': 'packets_receive_error',
                            'packets_sent_error': 'packets_sent_error',
                            }

    def __init__(self,
                 bytes_in=None,
                 bytes_out=None,
                 packets_in=None,
                 packets_out=None,
                 packets_receive_error=None,
                 packets_sent_error=None,
                ):
        """
        :type  bytes_in: :class:`long` or ``None``
        :param bytes_in: Total number of incoming bytes. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  bytes_out: :class:`long` or ``None``
        :param bytes_out: Total number of outgoing bytes. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  packets_in: :class:`long` or ``None``
        :param packets_in: Total number of incoming packets. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  packets_out: :class:`long` or ``None``
        :param packets_out: Total number of outgoing packets. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  packets_receive_error: :class:`long` or ``None``
        :param packets_receive_error: Total number of incoming packets dropped. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  packets_sent_error: :class:`long` or ``None``
        :param packets_sent_error: Total number of packets dropped while sending for any reason.
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.bytes_in = bytes_in
        self.bytes_out = bytes_out
        self.packets_in = packets_in
        self.packets_out = packets_out
        self.packets_receive_error = packets_receive_error
        self.packets_sent_error = packets_sent_error
        VapiStruct.__init__(self)


L2VPNTapTrafficStatistics._set_binding_type(type.StructType(
    'com.vmware.nsx.model.l2_VPN_tap_traffic_statistics', {
        'bytes_in': type.OptionalType(type.IntegerType()),
        'bytes_out': type.OptionalType(type.IntegerType()),
        'packets_in': type.OptionalType(type.IntegerType()),
        'packets_out': type.OptionalType(type.IntegerType()),
        'packets_receive_error': type.OptionalType(type.IntegerType()),
        'packets_sent_error': type.OptionalType(type.IntegerType()),
    },
    L2VPNTapTrafficStatistics,
    False,
    None))



class L2VPNTransportTunnelStatus(VapiStruct):
    """
    Transport tunnel status.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "L2VPNTransportTunnelStatus"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    RESOURCE_TYPE_IPSECVPNTRANSPORTSTATUS = "IPSecVPNTransportStatus"
    """


    """



    _canonical_to_pep_names = {
                            'resource_type': 'resource_type',
                            'tunnel_id': 'tunnel_id',
                            }

    def __init__(self,
                 resource_type='L2VPNTransportTunnelStatus',
                 tunnel_id=None,
                ):
        """
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            *
              :attr:`L2VPNTransportTunnelStatus.RESOURCE_TYPE_IPSECVPNTRANSPORTSTATUS`
            
             Resource types of L2VPN Transport tunnels
        :type  tunnel_id: :class:`ResourceReference` or ``None``
        :param tunnel_id: Transport tunnel id.
        """
        self._resource_type = resource_type
        self.tunnel_id = tunnel_id
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

L2VPNTransportTunnelStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.l2_VPN_transport_tunnel_status', {
        'resource_type': type.StringType(),
        'tunnel_id': type.OptionalType(type.ReferenceType(__name__, 'ResourceReference')),
    },
    L2VPNTransportTunnelStatus,
    False,
    None))



class L2VpnAttachmentContext(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "L2VpnAttachmentContext"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'local_egress_ip': 'local_egress_ip',
                            'tunnel_id': 'tunnel_id',
                            'allocate_addresses': 'allocate_addresses',
                            'resource_type': 'resource_type',
                            }

    def __init__(self,
                 local_egress_ip=None,
                 tunnel_id=None,
                 allocate_addresses=None,
                 resource_type='L2VpnAttachmentContext',
                ):
        """
        :type  local_egress_ip: :class:`list` of :class:`str` or ``None``
        :param local_egress_ip: List of local egress IP addresses, used for local egress
            optimization. format: address-or-block-or-range
        :type  tunnel_id: :class:`long` or ``None``
        :param tunnel_id: Tunnel Id to uniquely identify the extension. format: int32
        :type  allocate_addresses: :class:`str` or ``None``
        :param allocate_addresses: Possible values are: 
            
            * :attr:`AttachmentContext.ALLOCATE_ADDRESSES_IPPOOL`
            * :attr:`AttachmentContext.ALLOCATE_ADDRESSES_MACPOOL`
            * :attr:`AttachmentContext.ALLOCATE_ADDRESSES_BOTH`
            * :attr:`AttachmentContext.ALLOCATE_ADDRESSES_NONE`
            
            A flag to indicate whether to allocate addresses from allocation
            pools bound to the parent logical switch.
        :type  resource_type: :class:`str`
        :param resource_type: Used to identify which concrete class it is
        """
        self.local_egress_ip = local_egress_ip
        self.tunnel_id = tunnel_id
        self.allocate_addresses = allocate_addresses
        self._resource_type = resource_type
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

L2VpnAttachmentContext._set_binding_type(type.StructType(
    'com.vmware.nsx.model.l2_vpn_attachment_context', {
        'local_egress_ip': type.OptionalType(type.ListType(type.StringType())),
        'tunnel_id': type.OptionalType(type.IntegerType()),
        'allocate_addresses': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
    },
    L2VpnAttachmentContext,
    False,
    None))



class L2VpnService(VapiStruct):
    """
    Defines if service running as server or client Also defines all the common
    properties for the multiple L2VpnSessions associated with this service.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    MODE_SERVER = "SERVER"
    """


    """
    MODE_CLIENT = "CLIENT"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'enable_full_mesh': 'enable_full_mesh',
                            'enable_hub': 'enable_hub',
                            'logical_router_id': 'logical_router_id',
                            'logical_tap_ip_pool': 'logical_tap_ip_pool',
                            'mode': 'mode',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 enable_full_mesh=None,
                 enable_hub=None,
                 logical_router_id=None,
                 logical_tap_ip_pool=None,
                 mode=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  enable_full_mesh: :class:`bool` or ``None``
        :param enable_full_mesh: Full mesh topology auto disables traffic replication between
            connected peers. However, this property is deprecated. Please refer
            enable_hub property instead to control client to client forwarding
            via the server. The value of enable_full_mesh will not be used
            anymore. If enable_hub is not provided explicitly, the default
            value of it will be used.
        :type  enable_hub: :class:`bool` or ``None``
        :param enable_hub: This property only applies in SERVER mode. If set to true, traffic
            from any client will be replicated to all other clients. If set to
            false, traffic received from clients is only replicated to the
            local VPN endpoint.
        :type  logical_router_id: :class:`str` or ``None``
        :param logical_router_id: Logical router id
        :type  logical_tap_ip_pool: :class:`list` of :class:`str` or ``None``
        :param logical_tap_ip_pool: IP Pool to allocate local and peer endpoint IPs for L2VpnSession
            logical Tap. format: ipv4-cidr-block
        :type  mode: :class:`str` or ``None``
        :param mode: Possible values are: 
            
            * :attr:`L2VpnService.MODE_SERVER`
            * :attr:`L2VpnService.MODE_CLIENT`
            
            Specify an L2VPN service mode as SERVER or CLIENT. L2VPN service in
            SERVER mode requires user to configure L2VPN session explicitly.
            L2VPN service in CLIENT mode can use peercode generated from SERVER
            to configure L2VPN session.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.enable_full_mesh = enable_full_mesh
        self.enable_hub = enable_hub
        self.logical_router_id = logical_router_id
        self.logical_tap_ip_pool = logical_tap_ip_pool
        self.mode = mode
        VapiStruct.__init__(self)


L2VpnService._set_binding_type(type.StructType(
    'com.vmware.nsx.model.l2_vpn_service', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'enable_full_mesh': type.OptionalType(type.BooleanType()),
        'enable_hub': type.OptionalType(type.BooleanType()),
        'logical_router_id': type.OptionalType(type.StringType()),
        'logical_tap_ip_pool': type.OptionalType(type.ListType(type.StringType())),
        'mode': type.OptionalType(type.StringType()),
    },
    L2VpnService,
    False,
    None))



class L2VpnServiceListResult(VapiStruct):
    """
    Paginated list all the L2VPN services.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`L2VpnService` or ``None``
        :param results: L2VPN serivce list result
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


L2VpnServiceListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.l2_vpn_service_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'L2VpnService'))),
    },
    L2VpnServiceListResult,
    False,
    None))



class L2VpnSession(VapiStruct):
    """
    Defines the tunnel local and peer addresses along with the multiple
    tansport tunnels for redundancy. L2VpnSession belongs on to only one
    L2VpnService.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'enabled': 'enabled',
                            'l2vpn_service_id': 'l2vpn_service_id',
                            'transport_tunnels': 'transport_tunnels',
                            'tunnel_encapsulation': 'tunnel_encapsulation',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 enabled=None,
                 l2vpn_service_id=None,
                 transport_tunnels=None,
                 tunnel_encapsulation=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  enabled: :class:`bool` or ``None``
        :param enabled: Enable to extend all the associated logical switches.
        :type  l2vpn_service_id: :class:`str` or ``None``
        :param l2vpn_service_id: L2VPN service id
        :type  transport_tunnels: :class:`list` of :class:`ResourceReference` or ``None``
        :param transport_tunnels: List of transport tunnels for redundancy.
        :type  tunnel_encapsulation: :class:`L2VpnTunnelEncapsulation` or ``None``
        :param tunnel_encapsulation: Tunnel encapsulation config. For hub, this property should not be
            provided as it will be auto-generated. For spoke, this property
            must be provided.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.enabled = enabled
        self.l2vpn_service_id = l2vpn_service_id
        self.transport_tunnels = transport_tunnels
        self.tunnel_encapsulation = tunnel_encapsulation
        VapiStruct.__init__(self)


L2VpnSession._set_binding_type(type.StructType(
    'com.vmware.nsx.model.l2_vpn_session', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'enabled': type.OptionalType(type.BooleanType()),
        'l2vpn_service_id': type.OptionalType(type.StringType()),
        'transport_tunnels': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceReference'))),
        'tunnel_encapsulation': type.OptionalType(type.ReferenceType(__name__, 'L2VpnTunnelEncapsulation')),
    },
    L2VpnSession,
    False,
    None))



class L2VpnSessionListResult(VapiStruct):
    """
    Paginated list all the L2VPN sessions

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`L2VpnSession` or ``None``
        :param results: L2VPN sessions list result
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


L2VpnSessionListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.l2_vpn_session_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'L2VpnSession'))),
    },
    L2VpnSessionListResult,
    False,
    None))



class L2VpnSessionPeerCodes(VapiStruct):
    """
    Get the peer_code for each tunnel to paste on the remote end of the tunnel.
    Currently only stand-along/unmanaged edge is supported on the remote end of
    the tunnel.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'peer_codes': 'peer_codes',
                            }

    def __init__(self,
                 peer_codes=None,
                ):
        """
        :type  peer_codes: :class:`list` of :class:`L2VpnTunnelPeerCode` or ``None``
        :param peer_codes: List of peer codes per transport tunnel.
        """
        self.peer_codes = peer_codes
        VapiStruct.__init__(self)


L2VpnSessionPeerCodes._set_binding_type(type.StructType(
    'com.vmware.nsx.model.l2_vpn_session_peer_codes', {
        'peer_codes': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'L2VpnTunnelPeerCode'))),
    },
    L2VpnSessionPeerCodes,
    False,
    None))



class L2VpnTunnelEncapsulation(VapiStruct):
    """
    L2VPN tunnel encapsulation config

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    PROTOCOL_GRE = "GRE"
    """


    """



    _canonical_to_pep_names = {
                            'local_endpoint_ip': 'local_endpoint_ip',
                            'peer_endpoint_ip': 'peer_endpoint_ip',
                            'protocol': 'protocol',
                            }

    def __init__(self,
                 local_endpoint_ip=None,
                 peer_endpoint_ip=None,
                 protocol=None,
                ):
        """
        :type  local_endpoint_ip: :class:`str` or ``None``
        :param local_endpoint_ip: IP Address of the tunnel port. For hub, the IP is allocated from
            L2VpnService logical_tap_ip_pool. All sessions on same L2VpnService
            get the same local_endpoint_ip. For spoke, the IP must be provided.
            format: ipv4
        :type  peer_endpoint_ip: :class:`str` or ``None``
        :param peer_endpoint_ip: IP Address of the peer tunnel port. For hub, the IP is allocated
            from L2VpnService logical_tap_ip_pool. For spoke, the IP must be
            provided. format: ipv4
        :type  protocol: :class:`str` or ``None``
        :param protocol: Possible values are: 
            
            * :attr:`L2VpnTunnelEncapsulation.PROTOCOL_GRE`
            
             Encapsulation protocol used by the tunnel
        """
        self.local_endpoint_ip = local_endpoint_ip
        self.peer_endpoint_ip = peer_endpoint_ip
        self.protocol = protocol
        VapiStruct.__init__(self)


L2VpnTunnelEncapsulation._set_binding_type(type.StructType(
    'com.vmware.nsx.model.l2_vpn_tunnel_encapsulation', {
        'local_endpoint_ip': type.OptionalType(type.StringType()),
        'peer_endpoint_ip': type.OptionalType(type.StringType()),
        'protocol': type.OptionalType(type.StringType()),
    },
    L2VpnTunnelEncapsulation,
    False,
    None))



class L2VpnTunnelPeerCode(VapiStruct):
    """
    L2Vpn tunnel peer code

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'peer_code': 'peer_code',
                            'transport_tunnel': 'transport_tunnel',
                            }

    def __init__(self,
                 peer_code=None,
                 transport_tunnel=None,
                ):
        """
        :type  peer_code: :class:`str` or ``None``
        :param peer_code: Copy this code to paste on the remote end of the tunnel. This is a
            base64 encoded string which has all the configuration for tunnel.
            E.g tap device local/peer ips and protocol, encryption algorithm,
            etc. The peer code also contains a pre-shared key; be careful when
            sharing or storing it.
        :type  transport_tunnel: :class:`ResourceReference` or ``None``
        :param transport_tunnel: Transport tunnel
        """
        self.peer_code = peer_code
        self.transport_tunnel = transport_tunnel
        VapiStruct.__init__(self)


L2VpnTunnelPeerCode._set_binding_type(type.StructType(
    'com.vmware.nsx.model.l2_vpn_tunnel_peer_code', {
        'peer_code': type.OptionalType(type.StringType()),
        'transport_tunnel': type.OptionalType(type.ReferenceType(__name__, 'ResourceReference')),
    },
    L2VpnTunnelPeerCode,
    False,
    None))



class L4PortSetNSService(VapiStruct):
    """
    L4PortSet can be specified in comma separated notation of parts. Parts of a
    L4PortSet includes single integer or range of port in hyphen notation.
    Example of a PortSet: \"22, 33-70, 44\".

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "L4PortSetNSService"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    L4PROTOCOL_TCP = "TCP"
    """


    """
    L4PROTOCOL_UDP = "UDP"
    """


    """



    _canonical_to_pep_names = {
                            'destination_ports': 'destination_ports',
                            'l4_protocol': 'l4_protocol',
                            'source_ports': 'source_ports',
                            'resource_type': 'resource_type',
                            }

    def __init__(self,
                 destination_ports=None,
                 l4_protocol=None,
                 source_ports=None,
                 resource_type='L4PortSetNSService',
                ):
        """
        :type  destination_ports: :class:`list` of :class:`str` or ``None``
        :param destination_ports: Number of values should not exceed 15, ranges count as 2 values.
            format: port-or-range
        :type  l4_protocol: :class:`str` or ``None``
        :param l4_protocol: Possible values are: 
            
            * :attr:`L4PortSetNSService.L4PROTOCOL_TCP`
            * :attr:`L4PortSetNSService.L4PROTOCOL_UDP`
        :type  source_ports: :class:`list` of :class:`str` or ``None``
        :param source_ports: Number of values should not exceed 15, ranges count as 2 values.
            format: port-or-range
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`NSServiceElement.RESOURCE_TYPE_ETHERTYPENSSERVICE`
            * :attr:`NSServiceElement.RESOURCE_TYPE_IPPROTOCOLNSSERVICE`
            * :attr:`NSServiceElement.RESOURCE_TYPE_IGMPTYPENSSERVICE`
            * :attr:`NSServiceElement.RESOURCE_TYPE_ICMPTYPENSSERVICE`
            * :attr:`NSServiceElement.RESOURCE_TYPE_ALGTYPENSSERVICE`
            * :attr:`NSServiceElement.RESOURCE_TYPE_L4PORTSETNSSERVICE`
            
             The specific type of NSServiceElement
        """
        self.destination_ports = destination_ports
        self.l4_protocol = l4_protocol
        self.source_ports = source_ports
        self._resource_type = resource_type
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

L4PortSetNSService._set_binding_type(type.StructType(
    'com.vmware.nsx.model.l4_port_set_NS_service', {
        'destination_ports': type.OptionalType(type.ListType(type.StringType())),
        'l4_protocol': type.OptionalType(type.StringType()),
        'source_ports': type.OptionalType(type.ListType(type.StringType())),
        'resource_type': type.StringType(),
    },
    L4PortSetNSService,
    False,
    None))



class Label(VapiStruct):
    """
    Label that will be displayed for a UI element.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'condition': 'condition',
                            'hover': 'hover',
                            'icons': 'icons',
                            'navigation': 'navigation',
                            'text': 'text',
                            }

    def __init__(self,
                 condition=None,
                 hover=None,
                 icons=None,
                 navigation=None,
                 text=None,
                ):
        """
        :type  condition: :class:`str` or ``None``
        :param condition: If the condition is met then the label will be applied. Examples of
            expression syntax are provided under example_request section of
            CreateWidgetConfiguration API.
        :type  hover: :class:`bool` or ``None``
        :param hover: If true, displays the label only on hover
        :type  icons: :class:`list` of :class:`Icon` or ``None``
        :param icons: Icons to be applied at dashboard for the label
        :type  navigation: :class:`str` or ``None``
        :param navigation: Hyperlink of the specified UI page that provides details.
        :type  text: :class:`str` or ``None``
        :param text: Text to be displayed at the label.
        """
        self.condition = condition
        self.hover = hover
        self.icons = icons
        self.navigation = navigation
        self.text = text
        VapiStruct.__init__(self)


Label._set_binding_type(type.StructType(
    'com.vmware.nsx.model.label', {
        'condition': type.OptionalType(type.StringType()),
        'hover': type.OptionalType(type.BooleanType()),
        'icons': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Icon'))),
        'navigation': type.OptionalType(type.StringType()),
        'text': type.OptionalType(type.StringType()),
    },
    Label,
    False,
    None))



class LabelValueConfiguration(VapiStruct):
    """
    Represents a Label-Value widget configuration

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LabelValueConfiguration"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    SUB_TYPE_ALIGNED = "VERTICALLY_ALIGNED"
    """


    """



    _canonical_to_pep_names = {
                            'layout': 'layout',
                            'navigation': 'navigation',
                            'properties': 'properties',
                            'sub_type': 'sub_type',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'datasources': 'datasources',
                            'default_filter_value': 'default_filter_value',
                            'drilldown_id': 'drilldown_id',
                            'filter': 'filter',
                            'filter_value_required': 'filter_value_required',
                            'footer': 'footer',
                            'icons': 'icons',
                            'is_drilldown': 'is_drilldown',
                            'legend': 'legend',
                            'shared': 'shared',
                            'span': 'span',
                            'weight': 'weight',
                            }

    def __init__(self,
                 layout=None,
                 navigation=None,
                 properties=None,
                 sub_type=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='LabelValueConfiguration',
                 tags=None,
                 datasources=None,
                 default_filter_value=None,
                 drilldown_id=None,
                 filter=None,
                 filter_value_required=None,
                 footer=None,
                 icons=None,
                 is_drilldown=None,
                 legend=None,
                 shared=None,
                 span=None,
                 weight=None,
                ):
        """
        :type  layout: :class:`Layout` or ``None``
        :param layout: Layout of properties can be vertical or grid. If layout is not
            specified a default vertical layout is applied.
        :type  navigation: :class:`str` or ``None``
        :param navigation: Hyperlink of the specified UI page that provides details.
        :type  properties: :class:`list` of :class:`PropertyItem` or ``None``
        :param properties: An array of label-value properties.
        :type  sub_type: :class:`str` or ``None``
        :param sub_type: Possible values are: 
            
            * :attr:`LabelValueConfiguration.SUB_TYPE_ALIGNED`
            
            A sub-type of LabelValueConfiguration. If sub-type is not specified
            the parent type is rendered. For VERTICALLY_ALIGNED sub_type, the
            value is placed below the label.
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Title of the widget. If display_name is omitted, the widget will be
            shown without a title.
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_LABELVALUECONFIGURATION`
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_DONUTCONFIGURATION`
            *
              :attr:`WidgetConfiguration.RESOURCE_TYPE_MULTIWIDGETCONFIGURATION`
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_CONTAINERCONFIGURATION`
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_STATSCONFIGURATION`
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_GRIDCONFIGURATION`
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_GRAPHCONFIGURATION`
            *
              :attr:`WidgetConfiguration.RESOURCE_TYPE_CUSTOMWIDGETCONFIGURATION`
            *
              :attr:`WidgetConfiguration.RESOURCE_TYPE_DROPDOWNFILTERWIDGETCONFIGURATION`
            
            Supported visualization types are LabelValueConfiguration,
            DonutConfiguration, GridConfiguration, StatsConfiguration,
            MultiWidgetConfiguration, GraphConfiguration,
            ContainerConfiguration, CustomWidgetConfiguration and
            DropdownFilterWidgetConfiguration.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  datasources: :class:`list` of :class:`Datasource` or ``None``
        :param datasources: The 'datasources' represent the sources from which data will be
            fetched. Currently, only NSX-API is supported as a 'default'
            datasource. An example of specifying 'default' datasource along
            with the urls to fetch data from is given at 'example_request'
            section of 'CreateWidgetConfiguration' API.
        :type  default_filter_value: :class:`list` of :class:`DefaultFilterValue` or ``None``
        :param default_filter_value: Default filter values to be passed to datasources. This will be
            used when the report is requested without filter values.
        :type  drilldown_id: :class:`str` or ``None``
        :param drilldown_id: Id of drilldown widget, if any. Id should be a valid id of an
            existing widget. A widget is considered as drilldown widget when it
            is associated with any other widget and provides more detailed
            information about any data item from the parent widget.
        :type  filter: :class:`str` or ``None``
        :param filter: Id of filter widget for subscription, if any. Id should be a valid
            id of an existing filter widget. Filter widget should be from the
            same view. Datasource URLs should have placeholder values equal to
            filter alias to accept the filter value on filter change.
        :type  filter_value_required: :class:`bool` or ``None``
        :param filter_value_required: Flag to indicate that widget will continue to work without filter
            value. If this flag is set to false then default_filter_value is
            manadatory.
        :type  footer: :class:`Footer` or ``None``
        :param footer: 
        :type  icons: :class:`list` of :class:`Icon` or ``None``
        :param icons: Icons to be applied at dashboard for widgets and UI elements.
        :type  is_drilldown: :class:`bool` or ``None``
        :param is_drilldown: Set to true if this widget should be used as a drilldown.
        :type  legend: :class:`Legend` or ``None``
        :param legend: Legend to be displayed. If legend is not needed, do not include it.
        :type  shared: :class:`bool` or ``None``
        :param shared: Please use the property 'shared' of View instead of this. The
            widgets of a shared view are visible to other users.
        :type  span: :class:`long` or ``None``
        :param span: Represents the horizontal span of the widget / container. format:
            int32
        :type  weight: :class:`long` or ``None``
        :param weight: Specify relavite weight in WidgetItem for placement in a view.
            Please see WidgetItem for details. format: int32
        """
        self.layout = layout
        self.navigation = navigation
        self.properties = properties
        self.sub_type = sub_type
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        self.datasources = datasources
        self.default_filter_value = default_filter_value
        self.drilldown_id = drilldown_id
        self.filter = filter
        self.filter_value_required = filter_value_required
        self.footer = footer
        self.icons = icons
        self.is_drilldown = is_drilldown
        self.legend = legend
        self.shared = shared
        self.span = span
        self.weight = weight
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

LabelValueConfiguration._set_binding_type(type.StructType(
    'com.vmware.nsx.model.label_value_configuration', {
        'layout': type.OptionalType(type.ReferenceType(__name__, 'Layout')),
        'navigation': type.OptionalType(type.StringType()),
        'properties': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'PropertyItem'))),
        'sub_type': type.OptionalType(type.StringType()),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'datasources': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Datasource'))),
        'default_filter_value': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'DefaultFilterValue'))),
        'drilldown_id': type.OptionalType(type.StringType()),
        'filter': type.OptionalType(type.StringType()),
        'filter_value_required': type.OptionalType(type.BooleanType()),
        'footer': type.OptionalType(type.ReferenceType(__name__, 'Footer')),
        'icons': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Icon'))),
        'is_drilldown': type.OptionalType(type.BooleanType()),
        'legend': type.OptionalType(type.ReferenceType(__name__, 'Legend')),
        'shared': type.OptionalType(type.BooleanType()),
        'span': type.OptionalType(type.IntegerType()),
        'weight': type.OptionalType(type.IntegerType()),
    },
    LabelValueConfiguration,
    False,
    None))



class LacpGroupConfigInfo(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    MODE_ACTIVE = "ACTIVE"
    """


    """
    MODE_PASSIVE = "PASSIVE"
    """


    """



    _canonical_to_pep_names = {
                            'key': 'key',
                            'load_balance_algorithm': 'load_balance_algorithm',
                            'mode': 'mode',
                            'name': 'name',
                            'uplink_names': 'uplink_names',
                            'uplink_num': 'uplink_num',
                            'uplink_port_keys': 'uplink_port_keys',
                            }

    def __init__(self,
                 key=None,
                 load_balance_algorithm=None,
                 mode=None,
                 name=None,
                 uplink_names=None,
                 uplink_num=None,
                 uplink_port_keys=None,
                ):
        """
        :type  key: :class:`str` or ``None``
        :param key: The key represents the identifier for the group that is unique
            across VC.
        :type  load_balance_algorithm: :class:`str` or ``None``
        :param load_balance_algorithm: Load balance algorithm used in LACP group. The possible values are
            dictated by the values available in VC. Please refer
            VMwareDvsLacpLoadBalanceAlgorithm documentation for a full list of
            values. A few examples are srcDestIp where source and destination
            IP are considered, srcIp where only source IP is considered.
        :type  mode: :class:`str` or ``None``
        :param mode: Possible values are: 
            
            * :attr:`LacpGroupConfigInfo.MODE_ACTIVE`
            * :attr:`LacpGroupConfigInfo.MODE_PASSIVE`
            
            The mode of LACP can be ACTIVE or PASSIVE. If the mode is ACTIVE,
            LACP is enabled unconditionally. If the mode is PASSIVE, LACP is
            enabled only if LACP device is detected.
        :type  name: :class:`str` or ``None``
        :param name: The display name of the LACP group.
        :type  uplink_names: :class:`list` of :class:`str` or ``None``
        :param uplink_names: Names for the uplink ports in the group.
        :type  uplink_num: :class:`long` or ``None``
        :param uplink_num: The number of uplink ports format: int64
        :type  uplink_port_keys: :class:`list` of :class:`str` or ``None``
        :param uplink_port_keys: Keys for the uplink ports in the group. Each uplink port is
            assigned a key that is unique across VC.
        """
        self.key = key
        self.load_balance_algorithm = load_balance_algorithm
        self.mode = mode
        self.name = name
        self.uplink_names = uplink_names
        self.uplink_num = uplink_num
        self.uplink_port_keys = uplink_port_keys
        VapiStruct.__init__(self)


LacpGroupConfigInfo._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lacp_group_config_info', {
        'key': type.OptionalType(type.StringType()),
        'load_balance_algorithm': type.OptionalType(type.StringType()),
        'mode': type.OptionalType(type.StringType()),
        'name': type.OptionalType(type.StringType()),
        'uplink_names': type.OptionalType(type.ListType(type.StringType())),
        'uplink_num': type.OptionalType(type.IntegerType()),
        'uplink_port_keys': type.OptionalType(type.ListType(type.StringType())),
    },
    LacpGroupConfigInfo,
    False,
    None))



class Lag(VapiStruct):
    """
    LACP group

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    LOAD_BALANCE_ALGORITHM_SRCMAC = "SRCMAC"
    """


    """
    LOAD_BALANCE_ALGORITHM_DESTMAC = "DESTMAC"
    """


    """
    LOAD_BALANCE_ALGORITHM_SRCDESTMAC = "SRCDESTMAC"
    """


    """
    LOAD_BALANCE_ALGORITHM_SRCDESTIPVLAN = "SRCDESTIPVLAN"
    """


    """
    LOAD_BALANCE_ALGORITHM_SRCDESTMACIPPORT = "SRCDESTMACIPPORT"
    """


    """
    MODE_ACTIVE = "ACTIVE"
    """


    """
    MODE_PASSIVE = "PASSIVE"
    """


    """
    TIMEOUT_TYPE_SLOW = "SLOW"
    """


    """
    TIMEOUT_TYPE_FAST = "FAST"
    """


    """



    _canonical_to_pep_names = {
                            'id': 'id',
                            'load_balance_algorithm': 'load_balance_algorithm',
                            'mode': 'mode',
                            'name': 'name',
                            'number_of_uplinks': 'number_of_uplinks',
                            'timeout_type': 'timeout_type',
                            'uplinks': 'uplinks',
                            }

    def __init__(self,
                 id=None,
                 load_balance_algorithm=None,
                 mode=None,
                 name=None,
                 number_of_uplinks=None,
                 timeout_type=None,
                 uplinks=None,
                ):
        """
        :type  id: :class:`str` or ``None``
        :param id: unique id
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  load_balance_algorithm: :class:`str` or ``None``
        :param load_balance_algorithm: Possible values are: 
            
            * :attr:`Lag.LOAD_BALANCE_ALGORITHM_SRCMAC`
            * :attr:`Lag.LOAD_BALANCE_ALGORITHM_DESTMAC`
            * :attr:`Lag.LOAD_BALANCE_ALGORITHM_SRCDESTMAC`
            * :attr:`Lag.LOAD_BALANCE_ALGORITHM_SRCDESTIPVLAN`
            * :attr:`Lag.LOAD_BALANCE_ALGORITHM_SRCDESTMACIPPORT`
            
             LACP load balance Algorithm
        :type  mode: :class:`str` or ``None``
        :param mode: Possible values are: 
            
            * :attr:`Lag.MODE_ACTIVE`
            * :attr:`Lag.MODE_PASSIVE`
            
             LACP group mode
        :type  name: :class:`str` or ``None``
        :param name: Lag name
        :type  number_of_uplinks: :class:`long` or ``None``
        :param number_of_uplinks: number of uplinks format: int32
        :type  timeout_type: :class:`str` or ``None``
        :param timeout_type: Possible values are: 
            
            * :attr:`Lag.TIMEOUT_TYPE_SLOW`
            * :attr:`Lag.TIMEOUT_TYPE_FAST`
            
             LACP timeout type
        :type  uplinks: :class:`list` of :class:`Uplink` or ``None``
        :param uplinks: uplink names
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.id = id
        self.load_balance_algorithm = load_balance_algorithm
        self.mode = mode
        self.name = name
        self.number_of_uplinks = number_of_uplinks
        self.timeout_type = timeout_type
        self.uplinks = uplinks
        VapiStruct.__init__(self)


Lag._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lag', {
        'id': type.OptionalType(type.StringType()),
        'load_balance_algorithm': type.OptionalType(type.StringType()),
        'mode': type.OptionalType(type.StringType()),
        'name': type.OptionalType(type.StringType()),
        'number_of_uplinks': type.OptionalType(type.IntegerType()),
        'timeout_type': type.OptionalType(type.StringType()),
        'uplinks': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Uplink'))),
    },
    Lag,
    False,
    None))



class LatencyStatProfile(VapiStruct):
    """
    Latency stat service profile

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'pnic_latency_enabled': 'pnic_latency_enabled',
                            'sampling_interval': 'sampling_interval',
                            'sampling_rate': 'sampling_rate',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 pnic_latency_enabled=None,
                 sampling_interval=None,
                 sampling_rate=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  pnic_latency_enabled: :class:`bool` or ``None``
        :param pnic_latency_enabled: Enable or Disable pnic latency.
        :type  sampling_interval: :class:`long` or ``None``
        :param sampling_interval: Event nth milliseconds packet is sampled. format: int64
        :type  sampling_rate: :class:`long` or ``None``
        :param sampling_rate: Event nth packet is sampled. format: int64
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.pnic_latency_enabled = pnic_latency_enabled
        self.sampling_interval = sampling_interval
        self.sampling_rate = sampling_rate
        VapiStruct.__init__(self)


LatencyStatProfile._set_binding_type(type.StructType(
    'com.vmware.nsx.model.latency_stat_profile', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'pnic_latency_enabled': type.OptionalType(type.BooleanType()),
        'sampling_interval': type.OptionalType(type.IntegerType()),
        'sampling_rate': type.OptionalType(type.IntegerType()),
    },
    LatencyStatProfile,
    False,
    None))



class LatencyStatProfileListResult(VapiStruct):
    """
    List of latency profile

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`LatencyStatProfile` or ``None``
        :param results: Latency stat profile list.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


LatencyStatProfileListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.latency_stat_profile_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'LatencyStatProfile'))),
    },
    LatencyStatProfileListResult,
    False,
    None))



class Layout(VapiStruct):
    """
    Represents layout of a container or widget

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    TYPE_HORIZONTAL = "HORIZONTAL"
    """


    """
    TYPE_VERTICAL = "VERTICAL"
    """


    """
    TYPE_GRID = "GRID"
    """


    """



    _canonical_to_pep_names = {
                            'properties': 'properties',
                            'type': 'type',
                            }

    def __init__(self,
                 properties=None,
                 type=None,
                ):
        """
        :type  properties: :class:`LayoutProperties` or ``None``
        :param properties: 
        :type  type: :class:`str` or ``None``
        :param type: Possible values are: 
            
            * :attr:`Layout.TYPE_HORIZONTAL`
            * :attr:`Layout.TYPE_VERTICAL`
            * :attr:`Layout.TYPE_GRID`
            
            Describes layout of a container or widget. Layout describes how
            individual widgets are placed inside the container. For example, if
            HORIZONTAL is chosen widgets are placed side by side inside the
            container. If VERTICAL is chosen then widgets are placed one below
            the other. If GRID is chosen then the container or widget display
            area is divided into a grid of m rows and n columns, as specified
            in the properties, and the widgets are placed inside the grid.
        """
        self.properties = properties
        self.type = type
        VapiStruct.__init__(self)


Layout._set_binding_type(type.StructType(
    'com.vmware.nsx.model.layout', {
        'properties': type.OptionalType(type.ReferenceType(__name__, 'LayoutProperties')),
        'type': type.OptionalType(type.StringType()),
    },
    Layout,
    False,
    None))



class LayoutProperties(VapiStruct):
    """
    Properties of the layout of a container or widget

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'num_columns': 'num_columns',
                            'num_rows': 'num_rows',
                            }

    def __init__(self,
                 num_columns=None,
                 num_rows=None,
                ):
        """
        :type  num_columns: :class:`long` or ``None``
        :param num_columns: Describes the number of columns of grid layout of a container or
            widget. This property is applicable for grid layout only. format:
            int32
        :type  num_rows: :class:`long` or ``None``
        :param num_rows: Describes the number of rows of grid layout of a container or
            widget. This property is applicable for grid layout only. format:
            int32
        """
        self.num_columns = num_columns
        self.num_rows = num_rows
        VapiStruct.__init__(self)


LayoutProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.layout_properties', {
        'num_columns': type.OptionalType(type.IntegerType()),
        'num_rows': type.OptionalType(type.IntegerType()),
    },
    LayoutProperties,
    False,
    None))



class LbAccessListControl(VapiStruct):
    """
    LbAccessListControl is used to define how IP access list control can filter
    the connections from clients.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    ACTION_ALLOW = "ALLOW"
    """


    """
    ACTION_DROP = "DROP"
    """


    """



    _canonical_to_pep_names = {
                            'action': 'action',
                            'enabled': 'enabled',
                            'group_id': 'group_id',
                            }

    def __init__(self,
                 action=None,
                 enabled=None,
                 group_id=None,
                ):
        """
        :type  action: :class:`str` or ``None``
        :param action: Possible values are: 
            
            * :attr:`LbAccessListControl.ACTION_ALLOW`
            * :attr:`LbAccessListControl.ACTION_DROP`
            
            ALLOW means connections matching grouping object IP list are
            allowed and requests not matching grouping object IP list are
            dropped. DROP means connections matching grouping object IP list
            are dropped and requests not matching grouping object IP list are
            allowed.
        :type  enabled: :class:`bool` or ``None``
        :param enabled: The enabled flag indicates whether to enable access list control
            option. It is false by default.
        :type  group_id: :class:`str` or ``None``
        :param group_id: The identifier of grouping object which defines the IP addresses or
            ranges to match the client IP.
        """
        self.action = action
        self.enabled = enabled
        self.group_id = group_id
        VapiStruct.__init__(self)


LbAccessListControl._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_access_list_control', {
        'action': type.OptionalType(type.StringType()),
        'enabled': type.OptionalType(type.BooleanType()),
        'group_id': type.OptionalType(type.StringType()),
    },
    LbAccessListControl,
    False,
    None))



class LbActiveMonitor(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LbActiveMonitor"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'fall_count': 'fall_count',
                            'interval': 'interval',
                            'monitor_port': 'monitor_port',
                            'rise_count': 'rise_count',
                            'timeout': 'timeout',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            }

    def __init__(self,
                 fall_count=None,
                 interval=None,
                 monitor_port=None,
                 rise_count=None,
                 timeout=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='LbActiveMonitor',
                 tags=None,
                ):
        """
        :type  fall_count: :class:`long` or ``None``
        :param fall_count: num of consecutive checks must fail before marking it down format:
            int64
        :type  interval: :class:`long` or ``None``
        :param interval: the frequency at which the system issues the monitor check (in
            second) format: int64
        :type  monitor_port: :class:`str` or ``None``
        :param monitor_port: If the monitor port is specified, it would override pool member
            port setting for healthcheck. A port range is not supported. For
            ICMP monitor, monitor_port is not required. format: port-or-range
        :type  rise_count: :class:`long` or ``None``
        :param rise_count: num of consecutive checks must pass before marking it up format:
            int64
        :type  timeout: :class:`long` or ``None``
        :param timeout: the number of seconds the target has in which to respond to the
            monitor request format: int64
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`LbMonitor.RESOURCE_TYPE_LBHTTPMONITOR`
            * :attr:`LbMonitor.RESOURCE_TYPE_LBHTTPSMONITOR`
            * :attr:`LbMonitor.RESOURCE_TYPE_LBICMPMONITOR`
            * :attr:`LbMonitor.RESOURCE_TYPE_LBTCPMONITOR`
            * :attr:`LbMonitor.RESOURCE_TYPE_LBUDPMONITOR`
            * :attr:`LbMonitor.RESOURCE_TYPE_LBPASSIVEMONITOR`
            
            Load balancers monitor the health of backend servers to ensure
            traffic is not black holed. There are two types of healthchecks:
            active and passive. Passive healthchecks depend on failures in
            actual client traffic (e.g. RST from server in response to a client
            connection) to detect that the server or the application is down.
            In case of active healthchecks, load balancer itself initiates new
            connections (or sends ICMP ping) to the servers periodically to
            check their health, completely independent of any data traffic.
            Currently, active health monitors are supported for HTTP, HTTPS,
            TCP, UDP and ICMP protocols.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        """
        self.fall_count = fall_count
        self.interval = interval
        self.monitor_port = monitor_port
        self.rise_count = rise_count
        self.timeout = timeout
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

LbActiveMonitor._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_active_monitor', {
        'fall_count': type.OptionalType(type.IntegerType()),
        'interval': type.OptionalType(type.IntegerType()),
        'monitor_port': type.OptionalType(type.StringType()),
        'rise_count': type.OptionalType(type.IntegerType()),
        'timeout': type.OptionalType(type.IntegerType()),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
    },
    LbActiveMonitor,
    False,
    None))



class LbAppProfile(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LbAppProfile"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    RESOURCE_TYPE_LBHTTPPROFILE = "LbHttpProfile"
    """


    """
    RESOURCE_TYPE_LBFASTTCPPROFILE = "LbFastTcpProfile"
    """


    """
    RESOURCE_TYPE_LBFASTUDPPROFILE = "LbFastUdpProfile"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='LbAppProfile',
                 tags=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`LbAppProfile.RESOURCE_TYPE_LBHTTPPROFILE`
            * :attr:`LbAppProfile.RESOURCE_TYPE_LBFASTTCPPROFILE`
            * :attr:`LbAppProfile.RESOURCE_TYPE_LBFASTUDPPROFILE`
            
            An application profile can be bound to a virtual server to specify
            the application protocol characteristics. It is used to influence
            how load balancing is performed. Currently, three types of
            application profiles are supported: LbFastTCPProfile,
            LbFastUDPProfile and LbHttpProfile. LbFastTCPProfile or
            LbFastUDPProfile is typically used when the application is using a
            custom protocol or a standard protocol not supported by the load
            balancer. It is also used in cases where the user only wants L4
            load balancing mainly because L4 load balancing has much higher
            performance and scalability, and/or supports connection mirroring.
            LbHttpProfile is used for both HTTP and HTTPS applications. Though
            application rules, if bound to the virtual server, can be used to
            accomplish the same goal, LbHttpProfile is intended to simplify
            enabling certain common use cases.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

LbAppProfile._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_app_profile', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
    },
    LbAppProfile,
    False,
    None))



class LbAppProfileListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param results: paginated list of load balancer application profiles
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`LbAppProfile`. When methods return a value of this class as
            a return value, the attribute will contain all the attributes
            defined in :class:`LbAppProfile`.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


LbAppProfileListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_app_profile_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'LbAppProfile')]))),
    },
    LbAppProfileListResult,
    False,
    None))



class LbClientCertificateIssuerDnCondition(VapiStruct):
    """
    Match condition for client certficate issuer DN

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    MATCH_TYPE_STARTS_WITH = "STARTS_WITH"
    """


    """
    MATCH_TYPE_ENDS_WITH = "ENDS_WITH"
    """


    """
    MATCH_TYPE_EQUALS = "EQUALS"
    """


    """
    MATCH_TYPE_CONTAINS = "CONTAINS"
    """


    """
    MATCH_TYPE_REGEX = "REGEX"
    """


    """



    _canonical_to_pep_names = {
                            'case_sensitive': 'case_sensitive',
                            'issuer_dn': 'issuer_dn',
                            'match_type': 'match_type',
                            }

    def __init__(self,
                 case_sensitive=None,
                 issuer_dn=None,
                 match_type=None,
                ):
        """
        :type  case_sensitive: :class:`bool` or ``None``
        :param case_sensitive: If true, case is significant when comparing issuer DN value.
        :type  issuer_dn: :class:`str` or ``None``
        :param issuer_dn: Value of issuer DN
        :type  match_type: :class:`str` or ``None``
        :param match_type: Possible values are: 
            
            *
              :attr:`LbClientCertificateIssuerDnCondition.MATCH_TYPE_STARTS_WITH`
            * :attr:`LbClientCertificateIssuerDnCondition.MATCH_TYPE_ENDS_WITH`
            * :attr:`LbClientCertificateIssuerDnCondition.MATCH_TYPE_EQUALS`
            * :attr:`LbClientCertificateIssuerDnCondition.MATCH_TYPE_CONTAINS`
            * :attr:`LbClientCertificateIssuerDnCondition.MATCH_TYPE_REGEX`
            
             Match type of issuer DN
        """
        self.case_sensitive = case_sensitive
        self.issuer_dn = issuer_dn
        self.match_type = match_type
        VapiStruct.__init__(self)


LbClientCertificateIssuerDnCondition._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_client_certificate_issuer_dn_condition', {
        'case_sensitive': type.OptionalType(type.BooleanType()),
        'issuer_dn': type.OptionalType(type.StringType()),
        'match_type': type.OptionalType(type.StringType()),
    },
    LbClientCertificateIssuerDnCondition,
    False,
    None))



class LbClientCertificateSubjectDnCondition(VapiStruct):
    """
    Match condition for client certficate subject DN

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    MATCH_TYPE_STARTS_WITH = "STARTS_WITH"
    """


    """
    MATCH_TYPE_ENDS_WITH = "ENDS_WITH"
    """


    """
    MATCH_TYPE_EQUALS = "EQUALS"
    """


    """
    MATCH_TYPE_CONTAINS = "CONTAINS"
    """


    """
    MATCH_TYPE_REGEX = "REGEX"
    """


    """



    _canonical_to_pep_names = {
                            'case_sensitive': 'case_sensitive',
                            'match_type': 'match_type',
                            'subject_dn': 'subject_dn',
                            }

    def __init__(self,
                 case_sensitive=None,
                 match_type=None,
                 subject_dn=None,
                ):
        """
        :type  case_sensitive: :class:`bool` or ``None``
        :param case_sensitive: If true, case is significant when comparing subject DN value.
        :type  match_type: :class:`str` or ``None``
        :param match_type: Possible values are: 
            
            *
              :attr:`LbClientCertificateSubjectDnCondition.MATCH_TYPE_STARTS_WITH`
            *
              :attr:`LbClientCertificateSubjectDnCondition.MATCH_TYPE_ENDS_WITH`
            * :attr:`LbClientCertificateSubjectDnCondition.MATCH_TYPE_EQUALS`
            * :attr:`LbClientCertificateSubjectDnCondition.MATCH_TYPE_CONTAINS`
            * :attr:`LbClientCertificateSubjectDnCondition.MATCH_TYPE_REGEX`
            
             Match type of subject DN
        :type  subject_dn: :class:`str` or ``None``
        :param subject_dn: Value of subject DN
        """
        self.case_sensitive = case_sensitive
        self.match_type = match_type
        self.subject_dn = subject_dn
        VapiStruct.__init__(self)


LbClientCertificateSubjectDnCondition._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_client_certificate_subject_dn_condition', {
        'case_sensitive': type.OptionalType(type.BooleanType()),
        'match_type': type.OptionalType(type.StringType()),
        'subject_dn': type.OptionalType(type.StringType()),
    },
    LbClientCertificateSubjectDnCondition,
    False,
    None))



class LbClientSslProfile(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    CIPHER_GROUP_LABEL_BALANCED = "BALANCED"
    """


    """
    CIPHER_GROUP_LABEL_HIGH_SECURITY = "HIGH_SECURITY"
    """


    """
    CIPHER_GROUP_LABEL_HIGH_COMPATIBILITY = "HIGH_COMPATIBILITY"
    """


    """
    CIPHER_GROUP_LABEL_CUSTOM = "CUSTOM"
    """


    """
    CIPHERS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 = "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256"
    """


    """
    CIPHERS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 = "TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384"
    """


    """
    CIPHERS_ECDHE_RSA_WITH_AES_256_CBC_SHA = "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA"
    """


    """
    CIPHERS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA = "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA"
    """


    """
    CIPHERS_ECDH_ECDSA_WITH_AES_256_CBC_SHA = "TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA"
    """


    """
    CIPHERS_ECDH_RSA_WITH_AES_256_CBC_SHA = "TLS_ECDH_RSA_WITH_AES_256_CBC_SHA"
    """


    """
    CIPHERS_RSA_WITH_AES_256_CBC_SHA = "TLS_RSA_WITH_AES_256_CBC_SHA"
    """


    """
    CIPHERS_RSA_WITH_AES_128_CBC_SHA = "TLS_RSA_WITH_AES_128_CBC_SHA"
    """


    """
    CIPHERS_RSA_WITH_3DES_EDE_CBC_SHA = "TLS_RSA_WITH_3DES_EDE_CBC_SHA"
    """


    """
    CIPHERS_ECDHE_RSA_WITH_AES_128_CBC_SHA = "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA"
    """


    """
    CIPHERS_ECDHE_RSA_WITH_AES_128_CBC_SHA256 = "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256"
    """


    """
    CIPHERS_ECDHE_RSA_WITH_AES_256_CBC_SHA384 = "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384"
    """


    """
    CIPHERS_RSA_WITH_AES_128_CBC_SHA256 = "TLS_RSA_WITH_AES_128_CBC_SHA256"
    """


    """
    CIPHERS_RSA_WITH_AES_128_GCM_SHA256 = "TLS_RSA_WITH_AES_128_GCM_SHA256"
    """


    """
    CIPHERS_RSA_WITH_AES_256_CBC_SHA256 = "TLS_RSA_WITH_AES_256_CBC_SHA256"
    """


    """
    CIPHERS_RSA_WITH_AES_256_GCM_SHA384 = "TLS_RSA_WITH_AES_256_GCM_SHA384"
    """


    """
    CIPHERS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA = "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA"
    """


    """
    CIPHERS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256 = "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256"
    """


    """
    CIPHERS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 = "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256"
    """


    """
    CIPHERS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384 = "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384"
    """


    """
    CIPHERS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384 = "TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384"
    """


    """
    CIPHERS_ECDH_ECDSA_WITH_AES_128_CBC_SHA = "TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA"
    """


    """
    CIPHERS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256 = "TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256"
    """


    """
    CIPHERS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256 = "TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256"
    """


    """
    CIPHERS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384 = "TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384"
    """


    """
    CIPHERS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384 = "TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384"
    """


    """
    CIPHERS_ECDH_RSA_WITH_AES_128_CBC_SHA = "TLS_ECDH_RSA_WITH_AES_128_CBC_SHA"
    """


    """
    CIPHERS_ECDH_RSA_WITH_AES_128_CBC_SHA256 = "TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256"
    """


    """
    CIPHERS_ECDH_RSA_WITH_AES_128_GCM_SHA256 = "TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256"
    """


    """
    CIPHERS_ECDH_RSA_WITH_AES_256_CBC_SHA384 = "TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384"
    """


    """
    CIPHERS_ECDH_RSA_WITH_AES_256_GCM_SHA384 = "TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384"
    """


    """
    PROTOCOLS_SSL_V2 = "SSL_V2"
    """


    """
    PROTOCOLS_SSL_V3 = "SSL_V3"
    """


    """
    PROTOCOLS_TLS_V1 = "TLS_V1"
    """


    """
    PROTOCOLS_TLS_V1_1 = "TLS_V1_1"
    """


    """
    PROTOCOLS_TLS_V1_2 = "TLS_V1_2"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'cipher_group_label': 'cipher_group_label',
                            'ciphers': 'ciphers',
                            'is_fips': 'is_fips',
                            'is_secure': 'is_secure',
                            'prefer_server_ciphers': 'prefer_server_ciphers',
                            'protocols': 'protocols',
                            'session_cache_enabled': 'session_cache_enabled',
                            'session_cache_timeout': 'session_cache_timeout',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 cipher_group_label=None,
                 ciphers=None,
                 is_fips=None,
                 is_secure=None,
                 prefer_server_ciphers=None,
                 protocols=None,
                 session_cache_enabled=None,
                 session_cache_timeout=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  cipher_group_label: :class:`str` or ``None``
        :param cipher_group_label: Possible values are: 
            
            * :attr:`LbClientSslProfile.CIPHER_GROUP_LABEL_BALANCED`
            * :attr:`LbClientSslProfile.CIPHER_GROUP_LABEL_HIGH_SECURITY`
            * :attr:`LbClientSslProfile.CIPHER_GROUP_LABEL_HIGH_COMPATIBILITY`
            * :attr:`LbClientSslProfile.CIPHER_GROUP_LABEL_CUSTOM`
            
             It is a label of cipher group which is mostly consumed by GUI.
        :type  ciphers: :class:`list` of :class:`str` or ``None``
        :param ciphers: Possible values are: 
            
            *
              :attr:`LbClientSslProfile.CIPHERS_ECDHE_RSA_WITH_AES_128_GCM_SHA256`
            *
              :attr:`LbClientSslProfile.CIPHERS_ECDHE_RSA_WITH_AES_256_GCM_SHA384`
            * :attr:`LbClientSslProfile.CIPHERS_ECDHE_RSA_WITH_AES_256_CBC_SHA`
            *
              :attr:`LbClientSslProfile.CIPHERS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA`
            *
              :attr:`LbClientSslProfile.CIPHERS_ECDH_ECDSA_WITH_AES_256_CBC_SHA`
            * :attr:`LbClientSslProfile.CIPHERS_ECDH_RSA_WITH_AES_256_CBC_SHA`
            * :attr:`LbClientSslProfile.CIPHERS_RSA_WITH_AES_256_CBC_SHA`
            * :attr:`LbClientSslProfile.CIPHERS_RSA_WITH_AES_128_CBC_SHA`
            * :attr:`LbClientSslProfile.CIPHERS_RSA_WITH_3DES_EDE_CBC_SHA`
            * :attr:`LbClientSslProfile.CIPHERS_ECDHE_RSA_WITH_AES_128_CBC_SHA`
            *
              :attr:`LbClientSslProfile.CIPHERS_ECDHE_RSA_WITH_AES_128_CBC_SHA256`
            *
              :attr:`LbClientSslProfile.CIPHERS_ECDHE_RSA_WITH_AES_256_CBC_SHA384`
            * :attr:`LbClientSslProfile.CIPHERS_RSA_WITH_AES_128_CBC_SHA256`
            * :attr:`LbClientSslProfile.CIPHERS_RSA_WITH_AES_128_GCM_SHA256`
            * :attr:`LbClientSslProfile.CIPHERS_RSA_WITH_AES_256_CBC_SHA256`
            * :attr:`LbClientSslProfile.CIPHERS_RSA_WITH_AES_256_GCM_SHA384`
            *
              :attr:`LbClientSslProfile.CIPHERS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA`
            *
              :attr:`LbClientSslProfile.CIPHERS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256`
            *
              :attr:`LbClientSslProfile.CIPHERS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256`
            *
              :attr:`LbClientSslProfile.CIPHERS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384`
            *
              :attr:`LbClientSslProfile.CIPHERS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384`
            *
              :attr:`LbClientSslProfile.CIPHERS_ECDH_ECDSA_WITH_AES_128_CBC_SHA`
            *
              :attr:`LbClientSslProfile.CIPHERS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256`
            *
              :attr:`LbClientSslProfile.CIPHERS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256`
            *
              :attr:`LbClientSslProfile.CIPHERS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384`
            *
              :attr:`LbClientSslProfile.CIPHERS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384`
            * :attr:`LbClientSslProfile.CIPHERS_ECDH_RSA_WITH_AES_128_CBC_SHA`
            *
              :attr:`LbClientSslProfile.CIPHERS_ECDH_RSA_WITH_AES_128_CBC_SHA256`
            *
              :attr:`LbClientSslProfile.CIPHERS_ECDH_RSA_WITH_AES_128_GCM_SHA256`
            *
              :attr:`LbClientSslProfile.CIPHERS_ECDH_RSA_WITH_AES_256_CBC_SHA384`
            *
              :attr:`LbClientSslProfile.CIPHERS_ECDH_RSA_WITH_AES_256_GCM_SHA384`
            
             supported SSL cipher list to client side
        :type  is_fips: :class:`bool` or ``None``
        :param is_fips: This flag is set to true when all the ciphers and protocols are
            FIPS compliant. It is set to false when one of the ciphers or
            protocols are not FIPS compliant..
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  is_secure: :class:`bool` or ``None``
        :param is_secure: This flag is set to true when all the ciphers and protocols are
            secure. It is set to false when one of the ciphers or protocols is
            insecure.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  prefer_server_ciphers: :class:`bool` or ``None``
        :param prefer_server_ciphers: During SSL handshake as part of the SSL client Hello client sends
            an ordered list of ciphers that it can support (or prefers) and
            typically server selects the first one from the top of that list it
            can also support. For Perfect Forward Secrecy(PFS), server could
            override the client's preference.
        :type  protocols: :class:`list` of :class:`str` or ``None``
        :param protocols: Possible values are: 
            
            * :attr:`LbClientSslProfile.PROTOCOLS_SSL_V2`
            * :attr:`LbClientSslProfile.PROTOCOLS_SSL_V3`
            * :attr:`LbClientSslProfile.PROTOCOLS_TLS_V1`
            * :attr:`LbClientSslProfile.PROTOCOLS_TLS_V1_1`
            * :attr:`LbClientSslProfile.PROTOCOLS_TLS_V1_2`
            
            SSL versions TLS1.1 and TLS1.2 are supported and enabled by
            default. SSLv2, SSLv3, and TLS1.0 are supported, but disabled by
            default.
        :type  session_cache_enabled: :class:`bool` or ``None``
        :param session_cache_enabled: SSL session caching allows SSL client and server to reuse
            previously negotiated security parameters avoiding the expensive
            public key operation during handshake.
        :type  session_cache_timeout: :class:`long` or ``None``
        :param session_cache_timeout: Session cache timeout specifies how long the SSL session parameters
            are held on to and can be reused. format: int64
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.cipher_group_label = cipher_group_label
        self.ciphers = ciphers
        self.is_fips = is_fips
        self.is_secure = is_secure
        self.prefer_server_ciphers = prefer_server_ciphers
        self.protocols = protocols
        self.session_cache_enabled = session_cache_enabled
        self.session_cache_timeout = session_cache_timeout
        VapiStruct.__init__(self)


LbClientSslProfile._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_client_ssl_profile', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'cipher_group_label': type.OptionalType(type.StringType()),
        'ciphers': type.OptionalType(type.ListType(type.StringType())),
        'is_fips': type.OptionalType(type.BooleanType()),
        'is_secure': type.OptionalType(type.BooleanType()),
        'prefer_server_ciphers': type.OptionalType(type.BooleanType()),
        'protocols': type.OptionalType(type.ListType(type.StringType())),
        'session_cache_enabled': type.OptionalType(type.BooleanType()),
        'session_cache_timeout': type.OptionalType(type.IntegerType()),
    },
    LbClientSslProfile,
    False,
    None))



class LbClientSslProfileListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`LbClientSslProfile` or ``None``
        :param results: paginated list of load balancer client SSL profiles
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


LbClientSslProfileListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_client_ssl_profile_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'LbClientSslProfile'))),
    },
    LbClientSslProfileListResult,
    False,
    None))



class LbConnectionDropAction(VapiStruct):
    """
    This action is used to drop the connections. There is no extra propery in
    this action. If there is no match condition specified, the connection will
    be always dropped. This action can be specified at HTTP_ACCESS or
    HTTP_FORWARDING pahse.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LbConnectionDropAction"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'type': 'type',
                            }

    def __init__(self,
                 type='LbConnectionDropAction',
                ):
        """
        :type  type: :class:`str`
        :param type: Possible values are: 
            
            * :attr:`LbRuleAction.TYPE_LBHTTPREQUESTURIREWRITEACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPREQUESTHEADERREWRITEACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPREJECTACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPREDIRECTACTION`
            * :attr:`LbRuleAction.TYPE_LBSELECTPOOLACTION`
            * :attr:`LbRuleAction.TYPE_LBSELECTSERVERACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPRESPONSEHEADERREWRITEACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPREQUESTHEADERDELETEACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPRESPONSEHEADERDELETEACTION`
            * :attr:`LbRuleAction.TYPE_LBVARIABLEASSIGNMENTACTION`
            * :attr:`LbRuleAction.TYPE_LBVARIABLEPERSISTENCEONACTION`
            * :attr:`LbRuleAction.TYPE_LBVARIABLEPERSISTENCELEARNACTION`
            * :attr:`LbRuleAction.TYPE_LBJWTAUTHACTION`
            * :attr:`LbRuleAction.TYPE_LBSSLMODESELECTIONACTION`
            * :attr:`LbRuleAction.TYPE_LBCONNECTIONDROPACTION`
            
             The property identifies the load balancer rule action type.
        """
        self._type = type
        VapiStruct.__init__(self)

    @property
    def type(self):
        """
        Return the discriminator value
        """
        return self._type

LbConnectionDropAction._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_connection_drop_action', {
        'type': type.StringType(),
    },
    LbConnectionDropAction,
    False,
    None))



class LbCookiePersistenceProfile(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LbCookiePersistenceProfile"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    COOKIE_MODE_INSERT = "INSERT"
    """


    """
    COOKIE_MODE_PREFIX = "PREFIX"
    """


    """
    COOKIE_MODE_REWRITE = "REWRITE"
    """


    """



    _canonical_to_pep_names = {
                            'cookie_domain': 'cookie_domain',
                            'cookie_fallback': 'cookie_fallback',
                            'cookie_garble': 'cookie_garble',
                            'cookie_mode': 'cookie_mode',
                            'cookie_name': 'cookie_name',
                            'cookie_path': 'cookie_path',
                            'cookie_time': 'cookie_time',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'persistence_shared': 'persistence_shared',
                            }

    def __init__(self,
                 cookie_domain=None,
                 cookie_fallback=None,
                 cookie_garble=None,
                 cookie_mode=None,
                 cookie_name=None,
                 cookie_path=None,
                 cookie_time=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='LbCookiePersistenceProfile',
                 tags=None,
                 persistence_shared=None,
                ):
        """
        :type  cookie_domain: :class:`str` or ``None``
        :param cookie_domain: HTTP cookie domain could be configured, only available for insert
            mode.
        :type  cookie_fallback: :class:`bool` or ``None``
        :param cookie_fallback: If fallback is true, once the cookie points to a server that is
            down (i.e. admin state DISABLED or healthcheck state is DOWN), then
            a new server is selected by default to handle that request. If
            fallback is false, it will cause the request to be rejected if
            cookie points to a server
        :type  cookie_garble: :class:`bool` or ``None``
        :param cookie_garble: If garble is set to true, cookie value (server IP and port) would
            be encrypted. If garble is set to false, cookie value would be
            plain text.
        :type  cookie_mode: :class:`str` or ``None``
        :param cookie_mode: Possible values are: 
            
            * :attr:`LbCookiePersistenceProfile.COOKIE_MODE_INSERT`
            * :attr:`LbCookiePersistenceProfile.COOKIE_MODE_PREFIX`
            * :attr:`LbCookiePersistenceProfile.COOKIE_MODE_REWRITE`
            
             cookie persistence mode
        :type  cookie_name: :class:`str` or ``None``
        :param cookie_name: cookie name
        :type  cookie_path: :class:`str` or ``None``
        :param cookie_path: HTTP cookie path could be set, only available for insert mode.
        :type  cookie_time: :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param cookie_time: Both session cookie and persistence cookie are supported, if not
            specified, it's a session cookie. It expires when the browser is
            closed.
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`LbCookieTime`. When methods return a value of this class as
            a return value, the attribute will contain all the attributes
            defined in :class:`LbCookieTime`.
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            *
              :attr:`LbPersistenceProfile.RESOURCE_TYPE_LBCOOKIEPERSISTENCEPROFILE`
            *
              :attr:`LbPersistenceProfile.RESOURCE_TYPE_LBSOURCEIPPERSISTENCEPROFILE`
            *
              :attr:`LbPersistenceProfile.RESOURCE_TYPE_LBGENERICPERSISTENCEPROFILE`
            
             The resource_type property identifies persistence profile type.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  persistence_shared: :class:`bool` or ``None``
        :param persistence_shared: The persistence shared flag identifies whether the persistence
            table is shared among virtual-servers referring this profile. If
            persistence shared flag is not set in the cookie persistence
            profile bound to a virtual server, it defaults to cookie
            persistence that is private to each virtual server and is qualified
            by the pool. This is accomplished by load balancer inserting a
            cookie with name in the format
            <name>.<virtual_server_id>.<pool_id>. If persistence shared flag is
            set in the cookie persistence profile, in cookie insert mode,
            cookie persistence could be shared across multiple virtual servers
            that are bound to the same pools. The cookie name would be changed
            to <name>.<profile-id>.<pool-id>. If persistence shared flag is not
            set in the sourceIp persistence profile bound to a virtual server,
            each virtual server that the profile is bound to maintains its own
            private persistence table. If persistence shared flag is set in the
            sourceIp persistence profile, all virtual servers the profile is
            bound to share the same persistence table. If persistence shared
            flag is not set in the generic persistence profile, the persistence
            entries are matched and stored in the table which is identified
            using both virtual server ID and profile ID. If persistence shared
            flag is set in the generic persistence profile, the persistence
            entries are matched and stored in the table which is identified
            using profile ID. It means that virtual servers which consume the
            same profile in the LbRule with this flag enabled are sharing the
            same persistence table.
        """
        self.cookie_domain = cookie_domain
        self.cookie_fallback = cookie_fallback
        self.cookie_garble = cookie_garble
        self.cookie_mode = cookie_mode
        self.cookie_name = cookie_name
        self.cookie_path = cookie_path
        self.cookie_time = cookie_time
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        self.persistence_shared = persistence_shared
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

LbCookiePersistenceProfile._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_cookie_persistence_profile', {
        'cookie_domain': type.OptionalType(type.StringType()),
        'cookie_fallback': type.OptionalType(type.BooleanType()),
        'cookie_garble': type.OptionalType(type.BooleanType()),
        'cookie_mode': type.OptionalType(type.StringType()),
        'cookie_name': type.OptionalType(type.StringType()),
        'cookie_path': type.OptionalType(type.StringType()),
        'cookie_time': type.OptionalType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'LbCookieTime')])),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'persistence_shared': type.OptionalType(type.BooleanType()),
    },
    LbCookiePersistenceProfile,
    False,
    None))



class LbCookieTime(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LbCookieTime"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    TYPE_LBSESSIONCOOKIETIME = "LbSessionCookieTime"
    """


    """
    TYPE_LBPERSISTENCECOOKIETIME = "LbPersistenceCookieTime"
    """


    """



    _canonical_to_pep_names = {
                            'type': 'type',
                            }

    def __init__(self,
                 type='LbCookieTime',
                ):
        """
        :type  type: :class:`str`
        :param type: Possible values are: 
            
            * :attr:`LbCookieTime.TYPE_LBSESSIONCOOKIETIME`
            * :attr:`LbCookieTime.TYPE_LBPERSISTENCECOOKIETIME`
            
            Both session cookie and persistence cookie are supported, Use
            LbSessionCookieTime for session cookie time setting, Use
            LbPersistenceCookieTime for persistence cookie time setting
        """
        self._type = type
        VapiStruct.__init__(self)

    @property
    def type(self):
        """
        Return the discriminator value
        """
        return self._type

LbCookieTime._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_cookie_time', {
        'type': type.StringType(),
    },
    LbCookieTime,
    False,
    None))



class LbEdgeNodeUsage(VapiStruct):
    """
    The capacity contains basic information and load balancer entity usages and
    capacity for the given edge node.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LbEdgeNodeUsage"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    FORM_FACTOR_SMALL_VIRTUAL_MACHINE = "SMALL_VIRTUAL_MACHINE"
    """


    """
    FORM_FACTOR_MEDIUM_VIRTUAL_MACHINE = "MEDIUM_VIRTUAL_MACHINE"
    """


    """
    FORM_FACTOR_LARGE_VIRTUAL_MACHINE = "LARGE_VIRTUAL_MACHINE"
    """


    """
    FORM_FACTOR_XLARGE_VIRTUAL_MACHINE = "XLARGE_VIRTUAL_MACHINE"
    """


    """
    FORM_FACTOR_PHYSICAL_MACHINE = "PHYSICAL_MACHINE"
    """


    """
    SEVERITY_GREEN = "GREEN"
    """


    """
    SEVERITY_ORANGE = "ORANGE"
    """


    """
    SEVERITY_RED = "RED"
    """


    """



    _canonical_to_pep_names = {
                            'current_credit_number': 'current_credit_number',
                            'current_large_load_balancer_services': 'current_large_load_balancer_services',
                            'current_medium_load_balancer_services': 'current_medium_load_balancer_services',
                            'current_pool_members': 'current_pool_members',
                            'current_pools': 'current_pools',
                            'current_small_load_balancer_services': 'current_small_load_balancer_services',
                            'current_virtual_servers': 'current_virtual_servers',
                            'current_xlarge_load_balancer_services': 'current_xlarge_load_balancer_services',
                            'edge_cluster_id': 'edge_cluster_id',
                            'form_factor': 'form_factor',
                            'remaining_credit_number': 'remaining_credit_number',
                            'remaining_large_load_balancer_services': 'remaining_large_load_balancer_services',
                            'remaining_medium_load_balancer_services': 'remaining_medium_load_balancer_services',
                            'remaining_pool_members': 'remaining_pool_members',
                            'remaining_small_load_balancer_services': 'remaining_small_load_balancer_services',
                            'remaining_xlarge_load_balancer_services': 'remaining_xlarge_load_balancer_services',
                            'severity': 'severity',
                            'usage_percentage': 'usage_percentage',
                            'node_id': 'node_id',
                            'type': 'type',
                            }

    def __init__(self,
                 current_credit_number=None,
                 current_large_load_balancer_services=None,
                 current_medium_load_balancer_services=None,
                 current_pool_members=None,
                 current_pools=None,
                 current_small_load_balancer_services=None,
                 current_virtual_servers=None,
                 current_xlarge_load_balancer_services=None,
                 edge_cluster_id=None,
                 form_factor=None,
                 remaining_credit_number=None,
                 remaining_large_load_balancer_services=None,
                 remaining_medium_load_balancer_services=None,
                 remaining_pool_members=None,
                 remaining_small_load_balancer_services=None,
                 remaining_xlarge_load_balancer_services=None,
                 severity=None,
                 usage_percentage=None,
                 node_id=None,
                 type='LbEdgeNodeUsage',
                ):
        """
        :type  current_credit_number: :class:`long` or ``None``
        :param current_credit_number: The current credit number reflects the current usage on the node.
            For example, configuring a medium load balancer on a node consumes
            10 credits. If there are 2 medium instances configured on a node,
            the current credit number is 2 \* 10 = 20. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  current_large_load_balancer_services: :class:`long` or ``None``
        :param current_large_load_balancer_services: The number of large load balancer services configured on the node.
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  current_medium_load_balancer_services: :class:`long` or ``None``
        :param current_medium_load_balancer_services: The number of medium load balancer services configured on the node.
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  current_pool_members: :class:`long` or ``None``
        :param current_pool_members: The number of pool members configured on the node. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  current_pools: :class:`long` or ``None``
        :param current_pools: The number of pools configured on the node. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  current_small_load_balancer_services: :class:`long` or ``None``
        :param current_small_load_balancer_services: The number of small load balancer services configured on the node.
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  current_virtual_servers: :class:`long` or ``None``
        :param current_virtual_servers: The number of virtual servers configured on the node. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  current_xlarge_load_balancer_services: :class:`long` or ``None``
        :param current_xlarge_load_balancer_services: The number of xlarge load balancer services configured on the node.
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  edge_cluster_id: :class:`str` or ``None``
        :param edge_cluster_id: The ID of edge cluster which contains the edge node.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  form_factor: :class:`str` or ``None``
        :param form_factor: Possible values are: 
            
            * :attr:`LbEdgeNodeUsage.FORM_FACTOR_SMALL_VIRTUAL_MACHINE`
            * :attr:`LbEdgeNodeUsage.FORM_FACTOR_MEDIUM_VIRTUAL_MACHINE`
            * :attr:`LbEdgeNodeUsage.FORM_FACTOR_LARGE_VIRTUAL_MACHINE`
            * :attr:`LbEdgeNodeUsage.FORM_FACTOR_XLARGE_VIRTUAL_MACHINE`
            * :attr:`LbEdgeNodeUsage.FORM_FACTOR_PHYSICAL_MACHINE`
            
             The form factor of the given edge node.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  remaining_credit_number: :class:`long` or ``None``
        :param remaining_credit_number: The remaining credit number is the remaining credits that can be
            used for load balancer service configuration. For example, an edge
            node with form factor LARGE_VIRTUAL_MACHINE has 40 credits, and a
            medium load balancer instance costs 10 credits. If there are
            currently 3 medium instances configured, the remaining credit
            number is 40 - (3 \* 10) = 10. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  remaining_large_load_balancer_services: :class:`long` or ``None``
        :param remaining_large_load_balancer_services: The remaining number of large load balancer services which could be
            configured on the given edge node. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  remaining_medium_load_balancer_services: :class:`long` or ``None``
        :param remaining_medium_load_balancer_services: The remaining number of medium load balancer services which could
            be configured on the given edge node. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  remaining_pool_members: :class:`long` or ``None``
        :param remaining_pool_members: The remaining number of pool members which could be configured on
            the given edge node. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  remaining_small_load_balancer_services: :class:`long` or ``None``
        :param remaining_small_load_balancer_services: The remaining number of small load balancer services which could be
            configured on the given edge node. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  remaining_xlarge_load_balancer_services: :class:`long` or ``None``
        :param remaining_xlarge_load_balancer_services: The remaining number of xlarge load balancer services which could
            be configured on the given edge node. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  severity: :class:`str` or ``None``
        :param severity: Possible values are: 
            
            * :attr:`LbEdgeNodeUsage.SEVERITY_GREEN`
            * :attr:`LbEdgeNodeUsage.SEVERITY_ORANGE`
            * :attr:`LbEdgeNodeUsage.SEVERITY_RED`
            
            The severity calculation is based on current credit usage
            percentage of load balancer for one node.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  usage_percentage: :class:`float` or ``None``
        :param usage_percentage: The usage percentage of the edge node for load balancer. The value
            is the larger value between load balancer credit usage percentage
            and pool member usage percentage for the edge node.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  node_id: :class:`str` or ``None``
        :param node_id: The property identifies the node UUID for load balancer node usage.
        :type  type: :class:`str`
        :param type: Possible values are: 
            
            * :attr:`LbNodeUsage.TYPE_LBEDGENODEUSAGE`
            
             The property identifies the load balancer node usage type.
        """
        self.current_credit_number = current_credit_number
        self.current_large_load_balancer_services = current_large_load_balancer_services
        self.current_medium_load_balancer_services = current_medium_load_balancer_services
        self.current_pool_members = current_pool_members
        self.current_pools = current_pools
        self.current_small_load_balancer_services = current_small_load_balancer_services
        self.current_virtual_servers = current_virtual_servers
        self.current_xlarge_load_balancer_services = current_xlarge_load_balancer_services
        self.edge_cluster_id = edge_cluster_id
        self.form_factor = form_factor
        self.remaining_credit_number = remaining_credit_number
        self.remaining_large_load_balancer_services = remaining_large_load_balancer_services
        self.remaining_medium_load_balancer_services = remaining_medium_load_balancer_services
        self.remaining_pool_members = remaining_pool_members
        self.remaining_small_load_balancer_services = remaining_small_load_balancer_services
        self.remaining_xlarge_load_balancer_services = remaining_xlarge_load_balancer_services
        self.severity = severity
        self.usage_percentage = usage_percentage
        self.node_id = node_id
        self._type = type
        VapiStruct.__init__(self)

    @property
    def type(self):
        """
        Return the discriminator value
        """
        return self._type

LbEdgeNodeUsage._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_edge_node_usage', {
        'current_credit_number': type.OptionalType(type.IntegerType()),
        'current_large_load_balancer_services': type.OptionalType(type.IntegerType()),
        'current_medium_load_balancer_services': type.OptionalType(type.IntegerType()),
        'current_pool_members': type.OptionalType(type.IntegerType()),
        'current_pools': type.OptionalType(type.IntegerType()),
        'current_small_load_balancer_services': type.OptionalType(type.IntegerType()),
        'current_virtual_servers': type.OptionalType(type.IntegerType()),
        'current_xlarge_load_balancer_services': type.OptionalType(type.IntegerType()),
        'edge_cluster_id': type.OptionalType(type.StringType()),
        'form_factor': type.OptionalType(type.StringType()),
        'remaining_credit_number': type.OptionalType(type.IntegerType()),
        'remaining_large_load_balancer_services': type.OptionalType(type.IntegerType()),
        'remaining_medium_load_balancer_services': type.OptionalType(type.IntegerType()),
        'remaining_pool_members': type.OptionalType(type.IntegerType()),
        'remaining_small_load_balancer_services': type.OptionalType(type.IntegerType()),
        'remaining_xlarge_load_balancer_services': type.OptionalType(type.IntegerType()),
        'severity': type.OptionalType(type.StringType()),
        'usage_percentage': type.OptionalType(type.DoubleType()),
        'node_id': type.OptionalType(type.StringType()),
        'type': type.StringType(),
    },
    LbEdgeNodeUsage,
    False,
    None))



class LbFastTcpProfile(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LbFastTcpProfile"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'close_timeout': 'close_timeout',
                            'ha_flow_mirroring_enabled': 'ha_flow_mirroring_enabled',
                            'idle_timeout': 'idle_timeout',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            }

    def __init__(self,
                 close_timeout=None,
                 ha_flow_mirroring_enabled=None,
                 idle_timeout=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='LbFastTcpProfile',
                 tags=None,
                ):
        """
        :type  close_timeout: :class:`long` or ``None``
        :param close_timeout: It is used to specify how long a closing TCP connection (both FINs
            received or a RST is received) should be kept for this application
            before cleaning up the connection. format: int64
        :type  ha_flow_mirroring_enabled: :class:`bool` or ``None``
        :param ha_flow_mirroring_enabled: If flow mirroring is enabled, all the flows to the bounded virtual
            server are mirrored to the standby node.
        :type  idle_timeout: :class:`long` or ``None``
        :param idle_timeout: It is used to configure how long an idle TCP connection in
            ESTABLISHED state should be kept for this application before
            cleaning up. format: int64
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`LbAppProfile.RESOURCE_TYPE_LBHTTPPROFILE`
            * :attr:`LbAppProfile.RESOURCE_TYPE_LBFASTTCPPROFILE`
            * :attr:`LbAppProfile.RESOURCE_TYPE_LBFASTUDPPROFILE`
            
            An application profile can be bound to a virtual server to specify
            the application protocol characteristics. It is used to influence
            how load balancing is performed. Currently, three types of
            application profiles are supported: LbFastTCPProfile,
            LbFastUDPProfile and LbHttpProfile. LbFastTCPProfile or
            LbFastUDPProfile is typically used when the application is using a
            custom protocol or a standard protocol not supported by the load
            balancer. It is also used in cases where the user only wants L4
            load balancing mainly because L4 load balancing has much higher
            performance and scalability, and/or supports connection mirroring.
            LbHttpProfile is used for both HTTP and HTTPS applications. Though
            application rules, if bound to the virtual server, can be used to
            accomplish the same goal, LbHttpProfile is intended to simplify
            enabling certain common use cases.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        """
        self.close_timeout = close_timeout
        self.ha_flow_mirroring_enabled = ha_flow_mirroring_enabled
        self.idle_timeout = idle_timeout
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

LbFastTcpProfile._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_fast_tcp_profile', {
        'close_timeout': type.OptionalType(type.IntegerType()),
        'ha_flow_mirroring_enabled': type.OptionalType(type.BooleanType()),
        'idle_timeout': type.OptionalType(type.IntegerType()),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
    },
    LbFastTcpProfile,
    False,
    None))



class LbFastUdpProfile(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LbFastUdpProfile"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'flow_mirroring_enabled': 'flow_mirroring_enabled',
                            'idle_timeout': 'idle_timeout',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            }

    def __init__(self,
                 flow_mirroring_enabled=None,
                 idle_timeout=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='LbFastUdpProfile',
                 tags=None,
                ):
        """
        :type  flow_mirroring_enabled: :class:`bool` or ``None``
        :param flow_mirroring_enabled: If flow mirroring is enabled, all the flows to the bounded virtual
            server are mirrored to the standby node.
        :type  idle_timeout: :class:`long` or ``None``
        :param idle_timeout: Though UDP is a connectionless protocol, for the purposes of load
            balancing, all UDP packets with the same flow signature (source and
            destination IP/ports and IP protocol) received within the idle
            timeout period are considered to belong to the same connection and
            are sent to the same backend server. If no packets are received for
            idle timeout period, the connection (association between flow
            signature and the selected server) is cleaned up. format: int64
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`LbAppProfile.RESOURCE_TYPE_LBHTTPPROFILE`
            * :attr:`LbAppProfile.RESOURCE_TYPE_LBFASTTCPPROFILE`
            * :attr:`LbAppProfile.RESOURCE_TYPE_LBFASTUDPPROFILE`
            
            An application profile can be bound to a virtual server to specify
            the application protocol characteristics. It is used to influence
            how load balancing is performed. Currently, three types of
            application profiles are supported: LbFastTCPProfile,
            LbFastUDPProfile and LbHttpProfile. LbFastTCPProfile or
            LbFastUDPProfile is typically used when the application is using a
            custom protocol or a standard protocol not supported by the load
            balancer. It is also used in cases where the user only wants L4
            load balancing mainly because L4 load balancing has much higher
            performance and scalability, and/or supports connection mirroring.
            LbHttpProfile is used for both HTTP and HTTPS applications. Though
            application rules, if bound to the virtual server, can be used to
            accomplish the same goal, LbHttpProfile is intended to simplify
            enabling certain common use cases.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        """
        self.flow_mirroring_enabled = flow_mirroring_enabled
        self.idle_timeout = idle_timeout
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

LbFastUdpProfile._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_fast_udp_profile', {
        'flow_mirroring_enabled': type.OptionalType(type.BooleanType()),
        'idle_timeout': type.OptionalType(type.IntegerType()),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
    },
    LbFastUdpProfile,
    False,
    None))



class LbGenericPersistenceProfile(VapiStruct):
    """
    The profile is used to define the persistence entry expiration time,
    mirroring enabled flag to synchronize persistence entries, persistence
    shared flag for the associated virtual servers. The profile cannot be
    attached to virtual server directly, it can be only consumed by LB rule
    action. In HTTP forwarding phase, LBVariablePersistenceOnAction can be used
    to consume LbGenericPersistenceProfile. In HTTP response rewriting phase,
    LBVariablePersistenceLearnAction is used instead.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LbGenericPersistenceProfile"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'ha_persistence_mirroring_enabled': 'ha_persistence_mirroring_enabled',
                            'timeout': 'timeout',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'persistence_shared': 'persistence_shared',
                            }

    def __init__(self,
                 ha_persistence_mirroring_enabled=None,
                 timeout=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='LbGenericPersistenceProfile',
                 tags=None,
                 persistence_shared=None,
                ):
        """
        :type  ha_persistence_mirroring_enabled: :class:`bool` or ``None``
        :param ha_persistence_mirroring_enabled: The mirroring enabled flag is to synchronize persistence entries.
            Persistence entries are not synchronized to the HA peer by default.
        :type  timeout: :class:`long` or ``None``
        :param timeout: When all connections complete (reference count reaches 0),
            persistence entry timer is started with the expiration time.
            format: int64
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            *
              :attr:`LbPersistenceProfile.RESOURCE_TYPE_LBCOOKIEPERSISTENCEPROFILE`
            *
              :attr:`LbPersistenceProfile.RESOURCE_TYPE_LBSOURCEIPPERSISTENCEPROFILE`
            *
              :attr:`LbPersistenceProfile.RESOURCE_TYPE_LBGENERICPERSISTENCEPROFILE`
            
             The resource_type property identifies persistence profile type.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  persistence_shared: :class:`bool` or ``None``
        :param persistence_shared: The persistence shared flag identifies whether the persistence
            table is shared among virtual-servers referring this profile. If
            persistence shared flag is not set in the cookie persistence
            profile bound to a virtual server, it defaults to cookie
            persistence that is private to each virtual server and is qualified
            by the pool. This is accomplished by load balancer inserting a
            cookie with name in the format
            <name>.<virtual_server_id>.<pool_id>. If persistence shared flag is
            set in the cookie persistence profile, in cookie insert mode,
            cookie persistence could be shared across multiple virtual servers
            that are bound to the same pools. The cookie name would be changed
            to <name>.<profile-id>.<pool-id>. If persistence shared flag is not
            set in the sourceIp persistence profile bound to a virtual server,
            each virtual server that the profile is bound to maintains its own
            private persistence table. If persistence shared flag is set in the
            sourceIp persistence profile, all virtual servers the profile is
            bound to share the same persistence table. If persistence shared
            flag is not set in the generic persistence profile, the persistence
            entries are matched and stored in the table which is identified
            using both virtual server ID and profile ID. If persistence shared
            flag is set in the generic persistence profile, the persistence
            entries are matched and stored in the table which is identified
            using profile ID. It means that virtual servers which consume the
            same profile in the LbRule with this flag enabled are sharing the
            same persistence table.
        """
        self.ha_persistence_mirroring_enabled = ha_persistence_mirroring_enabled
        self.timeout = timeout
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        self.persistence_shared = persistence_shared
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

LbGenericPersistenceProfile._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_generic_persistence_profile', {
        'ha_persistence_mirroring_enabled': type.OptionalType(type.BooleanType()),
        'timeout': type.OptionalType(type.IntegerType()),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'persistence_shared': type.OptionalType(type.BooleanType()),
    },
    LbGenericPersistenceProfile,
    False,
    None))



class LbHttpMonitor(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    REQUEST_METHOD_GET = "GET"
    """


    """
    REQUEST_METHOD_OPTIONS = "OPTIONS"
    """


    """
    REQUEST_METHOD_POST = "POST"
    """


    """
    REQUEST_METHOD_HEAD = "HEAD"
    """


    """
    REQUEST_METHOD_PUT = "PUT"
    """


    """
    REQUEST_VERSION_1_0 = "HTTP_VERSION_1_0"
    """


    """
    REQUEST_VERSION_1_1 = "HTTP_VERSION_1_1"
    """


    """
    REQUEST_VERSION_2_0 = "HTTP_VERSION_2_0"
    """


    """



    _canonical_to_pep_names = {
                            'request_body': 'request_body',
                            'request_headers': 'request_headers',
                            'request_method': 'request_method',
                            'request_url': 'request_url',
                            'request_version': 'request_version',
                            'response_body': 'response_body',
                            'response_status_codes': 'response_status_codes',
                            'fall_count': 'fall_count',
                            'interval': 'interval',
                            'monitor_port': 'monitor_port',
                            'rise_count': 'rise_count',
                            'timeout': 'timeout',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            }

    def __init__(self,
                 request_body=None,
                 request_headers=None,
                 request_method=None,
                 request_url=None,
                 request_version=None,
                 response_body=None,
                 response_status_codes=None,
                 fall_count=None,
                 interval=None,
                 monitor_port=None,
                 rise_count=None,
                 timeout=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                ):
        """
        :type  request_body: :class:`str` or ``None``
        :param request_body: String to send as part of HTTP health check request body. Valid
            only for certain HTTP methods like POST.
        :type  request_headers: :class:`list` of :class:`LbHttpRequestHeader` or ``None``
        :param request_headers: Array of HTTP request headers
        :type  request_method: :class:`str` or ``None``
        :param request_method: Possible values are: 
            
            * :attr:`LbHttpMonitor.REQUEST_METHOD_GET`
            * :attr:`LbHttpMonitor.REQUEST_METHOD_OPTIONS`
            * :attr:`LbHttpMonitor.REQUEST_METHOD_POST`
            * :attr:`LbHttpMonitor.REQUEST_METHOD_HEAD`
            * :attr:`LbHttpMonitor.REQUEST_METHOD_PUT`
            
             the health check method for HTTP monitor type
        :type  request_url: :class:`str` or ``None``
        :param request_url: URL used for HTTP monitor
        :type  request_version: :class:`str` or ``None``
        :param request_version: Possible values are: 
            
            * :attr:`LbHttpMonitor.REQUEST_VERSION__1_0`
            * :attr:`LbHttpMonitor.REQUEST_VERSION__1_1`
            * :attr:`LbHttpMonitor.REQUEST_VERSION__2_0`
            
             HTTP request version
        :type  response_body: :class:`str` or ``None``
        :param response_body: If HTTP response body match string (regular expressions not
            supported) is specified (using LbHttpMonitor.response_body) then
            the healthcheck HTTP response body is matched against the specified
            string and server is considered healthy only if there is a match.
            If the response body string is not specified, HTTP healthcheck is
            considered successful if the HTTP response status code is 2xx, but
            it can be configured to accept other status codes as successful.
        :type  response_status_codes: :class:`list` of :class:`long` or ``None``
        :param response_status_codes: The HTTP response status code should be a valid HTTP status code.
            format: int32
        :type  fall_count: :class:`long` or ``None``
        :param fall_count: num of consecutive checks must fail before marking it down format:
            int64
        :type  interval: :class:`long` or ``None``
        :param interval: the frequency at which the system issues the monitor check (in
            second) format: int64
        :type  monitor_port: :class:`str` or ``None``
        :param monitor_port: If the monitor port is specified, it would override pool member
            port setting for healthcheck. A port range is not supported. For
            ICMP monitor, monitor_port is not required. format: port-or-range
        :type  rise_count: :class:`long` or ``None``
        :param rise_count: num of consecutive checks must pass before marking it up format:
            int64
        :type  timeout: :class:`long` or ``None``
        :param timeout: the number of seconds the target has in which to respond to the
            monitor request format: int64
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`LbMonitor.RESOURCE_TYPE_LBHTTPMONITOR`
            * :attr:`LbMonitor.RESOURCE_TYPE_LBHTTPSMONITOR`
            * :attr:`LbMonitor.RESOURCE_TYPE_LBICMPMONITOR`
            * :attr:`LbMonitor.RESOURCE_TYPE_LBTCPMONITOR`
            * :attr:`LbMonitor.RESOURCE_TYPE_LBUDPMONITOR`
            * :attr:`LbMonitor.RESOURCE_TYPE_LBPASSIVEMONITOR`
            
            Load balancers monitor the health of backend servers to ensure
            traffic is not black holed. There are two types of healthchecks:
            active and passive. Passive healthchecks depend on failures in
            actual client traffic (e.g. RST from server in response to a client
            connection) to detect that the server or the application is down.
            In case of active healthchecks, load balancer itself initiates new
            connections (or sends ICMP ping) to the servers periodically to
            check their health, completely independent of any data traffic.
            Currently, active health monitors are supported for HTTP, HTTPS,
            TCP, UDP and ICMP protocols.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        """
        self.request_body = request_body
        self.request_headers = request_headers
        self.request_method = request_method
        self.request_url = request_url
        self.request_version = request_version
        self.response_body = response_body
        self.response_status_codes = response_status_codes
        self.fall_count = fall_count
        self.interval = interval
        self.monitor_port = monitor_port
        self.rise_count = rise_count
        self.timeout = timeout
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

LbHttpMonitor._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_http_monitor', {
        'request_body': type.OptionalType(type.StringType()),
        'request_headers': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'LbHttpRequestHeader'))),
        'request_method': type.OptionalType(type.StringType()),
        'request_url': type.OptionalType(type.StringType()),
        'request_version': type.OptionalType(type.StringType()),
        'response_body': type.OptionalType(type.StringType()),
        'response_status_codes': type.OptionalType(type.ListType(type.IntegerType())),
        'fall_count': type.OptionalType(type.IntegerType()),
        'interval': type.OptionalType(type.IntegerType()),
        'monitor_port': type.OptionalType(type.StringType()),
        'rise_count': type.OptionalType(type.IntegerType()),
        'timeout': type.OptionalType(type.IntegerType()),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
    },
    LbHttpMonitor,
    False,
    None))



class LbHttpProfile(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LbHttpProfile"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    XFORWARDED_FOR_INSERT = "INSERT"
    """


    """
    XFORWARDED_FOR_REPLACE = "REPLACE"
    """


    """



    _canonical_to_pep_names = {
                            'http_redirect_to': 'http_redirect_to',
                            'http_redirect_to_https': 'http_redirect_to_https',
                            'idle_timeout': 'idle_timeout',
                            'ntlm': 'ntlm',
                            'request_body_size': 'request_body_size',
                            'request_header_size': 'request_header_size',
                            'response_buffering': 'response_buffering',
                            'response_header_size': 'response_header_size',
                            'response_timeout': 'response_timeout',
                            'x_forwarded_for': 'x_forwarded_for',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            }

    def __init__(self,
                 http_redirect_to=None,
                 http_redirect_to_https=None,
                 idle_timeout=None,
                 ntlm=None,
                 request_body_size=None,
                 request_header_size=None,
                 response_buffering=None,
                 response_header_size=None,
                 response_timeout=None,
                 x_forwarded_for=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='LbHttpProfile',
                 tags=None,
                ):
        """
        :type  http_redirect_to: :class:`str` or ``None``
        :param http_redirect_to: If a website is temporarily down or has moved, incoming requests
            for that virtual server can be temporarily redirected to a URL
        :type  http_redirect_to_https: :class:`bool` or ``None``
        :param http_redirect_to_https: Certain secure applications may want to force communication over
            SSL, but instead of rejecting non-SSL connections, they may choose
            to redirect the client automatically to use SSL.
        :type  idle_timeout: :class:`long` or ``None``
        :param idle_timeout: It is used to specify the HTTP application idle timeout, it means
            that how long the load balancer will keep the connection idle to
            wait for the client to send the next keep-alive request. It is not
            a TCP socket setting. format: int64
        :type  ntlm: :class:`bool` or ``None``
        :param ntlm: NTLM is an authentication protocol that can be used over HTTP. If
            the flag is set to true, LB will use NTLM challenge/response
            methodology.
        :type  request_body_size: :class:`long` or ``None``
        :param request_body_size: If it is not specified, it means that request body size is
            unlimited. format: int64
        :type  request_header_size: :class:`long` or ``None``
        :param request_header_size: A request with header equal to or below this size is guaranteed to
            be processed. A request with header larger than request_header_size
            will be processed up to 32K bytes on best effort basis. format:
            int64
        :type  response_buffering: :class:`bool` or ``None``
        :param response_buffering: When buffering is disabled, the response is passed to a client
            synchronously, immediately as it is received. When buffering is
            enabled, LB receives a response from the backend server as soon as
            possible, saving it into the buffers.
        :type  response_header_size: :class:`long` or ``None``
        :param response_header_size: A response with header larger than response_header_size will be
            dropped. format: int64
        :type  response_timeout: :class:`long` or ``None``
        :param response_timeout: If server doesn't send any packet within this time, the connection
            is closed. format: int64
        :type  x_forwarded_for: :class:`str` or ``None``
        :param x_forwarded_for: Possible values are: 
            
            * :attr:`LbHttpProfile.XFORWARDED_FOR_INSERT`
            * :attr:`LbHttpProfile.XFORWARDED_FOR_REPLACE`
            
            When X-Forwareded-For is configured, X-Forwarded-Proto and
            X-Forwarded-Port information is added automatically. The two
            additional header information can be also modified or deleted in
            load balancer rules.
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`LbAppProfile.RESOURCE_TYPE_LBHTTPPROFILE`
            * :attr:`LbAppProfile.RESOURCE_TYPE_LBFASTTCPPROFILE`
            * :attr:`LbAppProfile.RESOURCE_TYPE_LBFASTUDPPROFILE`
            
            An application profile can be bound to a virtual server to specify
            the application protocol characteristics. It is used to influence
            how load balancing is performed. Currently, three types of
            application profiles are supported: LbFastTCPProfile,
            LbFastUDPProfile and LbHttpProfile. LbFastTCPProfile or
            LbFastUDPProfile is typically used when the application is using a
            custom protocol or a standard protocol not supported by the load
            balancer. It is also used in cases where the user only wants L4
            load balancing mainly because L4 load balancing has much higher
            performance and scalability, and/or supports connection mirroring.
            LbHttpProfile is used for both HTTP and HTTPS applications. Though
            application rules, if bound to the virtual server, can be used to
            accomplish the same goal, LbHttpProfile is intended to simplify
            enabling certain common use cases.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        """
        self.http_redirect_to = http_redirect_to
        self.http_redirect_to_https = http_redirect_to_https
        self.idle_timeout = idle_timeout
        self.ntlm = ntlm
        self.request_body_size = request_body_size
        self.request_header_size = request_header_size
        self.response_buffering = response_buffering
        self.response_header_size = response_header_size
        self.response_timeout = response_timeout
        self.x_forwarded_for = x_forwarded_for
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

LbHttpProfile._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_http_profile', {
        'http_redirect_to': type.OptionalType(type.StringType()),
        'http_redirect_to_https': type.OptionalType(type.BooleanType()),
        'idle_timeout': type.OptionalType(type.IntegerType()),
        'ntlm': type.OptionalType(type.BooleanType()),
        'request_body_size': type.OptionalType(type.IntegerType()),
        'request_header_size': type.OptionalType(type.IntegerType()),
        'response_buffering': type.OptionalType(type.BooleanType()),
        'response_header_size': type.OptionalType(type.IntegerType()),
        'response_timeout': type.OptionalType(type.IntegerType()),
        'x_forwarded_for': type.OptionalType(type.StringType()),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
    },
    LbHttpProfile,
    False,
    None))



class LbHttpRedirectAction(VapiStruct):
    """
    This action is used to redirect HTTP request messages to a new URL. The
    reply_status value specified in this action is used as the status code of
    HTTP response message which is sent back to client (Normally a browser).
    The HTTP status code for redirection is 3xx, for example, 301, 302, 303,
    307, etc. The redirect_url is the new URL that the HTTP request message is
    redirected to. Normally browser will send another HTTP request to the new
    URL after receiving a redirection response message. Captured variables and
    built-in variables can be used in redirect_url field. For example, to
    redirect all HTTP requests to HTTPS requests for a virtual server. We
    create an LbRule without any conditions, add an LbHttpRedirectAction to the
    rule. Set the redirect_url field of the LbHttpRedirectAction to:
    https://$_host$_request_uri And set redirect_status to \"302\", which means
    found. This rule will redirect all HTTP requests to HTTPS server port on
    the same host.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LbHttpRedirectAction"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'redirect_status': 'redirect_status',
                            'redirect_url': 'redirect_url',
                            'type': 'type',
                            }

    def __init__(self,
                 redirect_status=None,
                 redirect_url=None,
                 type='LbHttpRedirectAction',
                ):
        """
        :type  redirect_status: :class:`str` or ``None``
        :param redirect_status: HTTP response status code
        :type  redirect_url: :class:`str` or ``None``
        :param redirect_url: The URL that the HTTP request is redirected to
        :type  type: :class:`str`
        :param type: Possible values are: 
            
            * :attr:`LbRuleAction.TYPE_LBHTTPREQUESTURIREWRITEACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPREQUESTHEADERREWRITEACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPREJECTACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPREDIRECTACTION`
            * :attr:`LbRuleAction.TYPE_LBSELECTPOOLACTION`
            * :attr:`LbRuleAction.TYPE_LBSELECTSERVERACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPRESPONSEHEADERREWRITEACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPREQUESTHEADERDELETEACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPRESPONSEHEADERDELETEACTION`
            * :attr:`LbRuleAction.TYPE_LBVARIABLEASSIGNMENTACTION`
            * :attr:`LbRuleAction.TYPE_LBVARIABLEPERSISTENCEONACTION`
            * :attr:`LbRuleAction.TYPE_LBVARIABLEPERSISTENCELEARNACTION`
            * :attr:`LbRuleAction.TYPE_LBJWTAUTHACTION`
            * :attr:`LbRuleAction.TYPE_LBSSLMODESELECTIONACTION`
            * :attr:`LbRuleAction.TYPE_LBCONNECTIONDROPACTION`
            
             The property identifies the load balancer rule action type.
        """
        self.redirect_status = redirect_status
        self.redirect_url = redirect_url
        self._type = type
        VapiStruct.__init__(self)

    @property
    def type(self):
        """
        Return the discriminator value
        """
        return self._type

LbHttpRedirectAction._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_http_redirect_action', {
        'redirect_status': type.OptionalType(type.StringType()),
        'redirect_url': type.OptionalType(type.StringType()),
        'type': type.StringType(),
    },
    LbHttpRedirectAction,
    False,
    None))



class LbHttpRejectAction(VapiStruct):
    """
    This action is used to reject HTTP request messages. The specified
    reply_status value is used as the status code for the corresponding HTTP
    response message which is sent back to client (Normally a browser)
    indicating the reason it was rejected. Reference official HTTP status code
    list for your specific HTTP version to set the reply_status properly.
    LbHttpRejectAction does not support variables.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LbHttpRejectAction"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'reply_message': 'reply_message',
                            'reply_status': 'reply_status',
                            'type': 'type',
                            }

    def __init__(self,
                 reply_message=None,
                 reply_status=None,
                 type='LbHttpRejectAction',
                ):
        """
        :type  reply_message: :class:`str` or ``None``
        :param reply_message: Response message
        :type  reply_status: :class:`str` or ``None``
        :param reply_status: HTTP response status code
        :type  type: :class:`str`
        :param type: Possible values are: 
            
            * :attr:`LbRuleAction.TYPE_LBHTTPREQUESTURIREWRITEACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPREQUESTHEADERREWRITEACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPREJECTACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPREDIRECTACTION`
            * :attr:`LbRuleAction.TYPE_LBSELECTPOOLACTION`
            * :attr:`LbRuleAction.TYPE_LBSELECTSERVERACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPRESPONSEHEADERREWRITEACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPREQUESTHEADERDELETEACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPRESPONSEHEADERDELETEACTION`
            * :attr:`LbRuleAction.TYPE_LBVARIABLEASSIGNMENTACTION`
            * :attr:`LbRuleAction.TYPE_LBVARIABLEPERSISTENCEONACTION`
            * :attr:`LbRuleAction.TYPE_LBVARIABLEPERSISTENCELEARNACTION`
            * :attr:`LbRuleAction.TYPE_LBJWTAUTHACTION`
            * :attr:`LbRuleAction.TYPE_LBSSLMODESELECTIONACTION`
            * :attr:`LbRuleAction.TYPE_LBCONNECTIONDROPACTION`
            
             The property identifies the load balancer rule action type.
        """
        self.reply_message = reply_message
        self.reply_status = reply_status
        self._type = type
        VapiStruct.__init__(self)

    @property
    def type(self):
        """
        Return the discriminator value
        """
        return self._type

LbHttpRejectAction._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_http_reject_action', {
        'reply_message': type.OptionalType(type.StringType()),
        'reply_status': type.OptionalType(type.StringType()),
        'type': type.StringType(),
    },
    LbHttpRejectAction,
    False,
    None))



class LbHttpRequestBodyCondition(VapiStruct):
    """
    This condition is used to match the message body of an HTTP request.
    Typically, only HTTP POST, PATCH, or PUT requests have request body. The
    match_type field defines how body_value field is used to match the body of
    HTTP requests.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LbHttpRequestBodyCondition"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    MATCH_TYPE_STARTS_WITH = "STARTS_WITH"
    """


    """
    MATCH_TYPE_ENDS_WITH = "ENDS_WITH"
    """


    """
    MATCH_TYPE_EQUALS = "EQUALS"
    """


    """
    MATCH_TYPE_CONTAINS = "CONTAINS"
    """


    """
    MATCH_TYPE_REGEX = "REGEX"
    """


    """



    _canonical_to_pep_names = {
                            'body_value': 'body_value',
                            'case_sensitive': 'case_sensitive',
                            'match_type': 'match_type',
                            'inverse': 'inverse',
                            'type': 'type',
                            }

    def __init__(self,
                 body_value=None,
                 case_sensitive=None,
                 match_type=None,
                 inverse=None,
                 type='LbHttpRequestBodyCondition',
                ):
        """
        :type  body_value: :class:`str` or ``None``
        :param body_value: HTTP request body
        :type  case_sensitive: :class:`bool` or ``None``
        :param case_sensitive: If true, case is significant when comparing HTTP body value.
        :type  match_type: :class:`str` or ``None``
        :param match_type: Possible values are: 
            
            * :attr:`LbHttpRequestBodyCondition.MATCH_TYPE_STARTS_WITH`
            * :attr:`LbHttpRequestBodyCondition.MATCH_TYPE_ENDS_WITH`
            * :attr:`LbHttpRequestBodyCondition.MATCH_TYPE_EQUALS`
            * :attr:`LbHttpRequestBodyCondition.MATCH_TYPE_CONTAINS`
            * :attr:`LbHttpRequestBodyCondition.MATCH_TYPE_REGEX`
            
             Match type of HTTP body
        :type  inverse: :class:`bool` or ``None``
        :param inverse: A flag to indicate whether reverse the match result of this
            condition
        :type  type: :class:`str`
        :param type: Possible values are: 
            
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTMETHODCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTURICONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTURIARGUMENTSCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTVERSIONCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTHEADERCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTCOOKIECONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTBODYCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPRESPONSEHEADERCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBTCPHEADERCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBIPHEADERCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBVARIABLECONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPSSLCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBSSLSNICONDITION`
            
             Type of load balancer rule condition
        """
        self.body_value = body_value
        self.case_sensitive = case_sensitive
        self.match_type = match_type
        self.inverse = inverse
        self._type = type
        VapiStruct.__init__(self)

    @property
    def type(self):
        """
        Return the discriminator value
        """
        return self._type

LbHttpRequestBodyCondition._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_http_request_body_condition', {
        'body_value': type.OptionalType(type.StringType()),
        'case_sensitive': type.OptionalType(type.BooleanType()),
        'match_type': type.OptionalType(type.StringType()),
        'inverse': type.OptionalType(type.BooleanType()),
        'type': type.StringType(),
    },
    LbHttpRequestBodyCondition,
    False,
    None))



class LbHttpRequestCookieCondition(VapiStruct):
    """
    This condition is used to match HTTP request messages by cookie which is a
    specific type of HTTP header. The match_type and case_sensitive define how
    to compare cookie value.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LbHttpRequestCookieCondition"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    MATCH_TYPE_STARTS_WITH = "STARTS_WITH"
    """


    """
    MATCH_TYPE_ENDS_WITH = "ENDS_WITH"
    """


    """
    MATCH_TYPE_EQUALS = "EQUALS"
    """


    """
    MATCH_TYPE_CONTAINS = "CONTAINS"
    """


    """
    MATCH_TYPE_REGEX = "REGEX"
    """


    """



    _canonical_to_pep_names = {
                            'case_sensitive': 'case_sensitive',
                            'cookie_name': 'cookie_name',
                            'cookie_value': 'cookie_value',
                            'match_type': 'match_type',
                            'inverse': 'inverse',
                            'type': 'type',
                            }

    def __init__(self,
                 case_sensitive=None,
                 cookie_name=None,
                 cookie_value=None,
                 match_type=None,
                 inverse=None,
                 type='LbHttpRequestCookieCondition',
                ):
        """
        :type  case_sensitive: :class:`bool` or ``None``
        :param case_sensitive: If true, case is significant when comparing cookie value.
        :type  cookie_name: :class:`str` or ``None``
        :param cookie_name: Name of cookie
        :type  cookie_value: :class:`str` or ``None``
        :param cookie_value: Value of cookie
        :type  match_type: :class:`str` or ``None``
        :param match_type: Possible values are: 
            
            * :attr:`LbHttpRequestCookieCondition.MATCH_TYPE_STARTS_WITH`
            * :attr:`LbHttpRequestCookieCondition.MATCH_TYPE_ENDS_WITH`
            * :attr:`LbHttpRequestCookieCondition.MATCH_TYPE_EQUALS`
            * :attr:`LbHttpRequestCookieCondition.MATCH_TYPE_CONTAINS`
            * :attr:`LbHttpRequestCookieCondition.MATCH_TYPE_REGEX`
            
             Match type of cookie value
        :type  inverse: :class:`bool` or ``None``
        :param inverse: A flag to indicate whether reverse the match result of this
            condition
        :type  type: :class:`str`
        :param type: Possible values are: 
            
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTMETHODCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTURICONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTURIARGUMENTSCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTVERSIONCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTHEADERCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTCOOKIECONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTBODYCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPRESPONSEHEADERCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBTCPHEADERCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBIPHEADERCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBVARIABLECONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPSSLCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBSSLSNICONDITION`
            
             Type of load balancer rule condition
        """
        self.case_sensitive = case_sensitive
        self.cookie_name = cookie_name
        self.cookie_value = cookie_value
        self.match_type = match_type
        self.inverse = inverse
        self._type = type
        VapiStruct.__init__(self)

    @property
    def type(self):
        """
        Return the discriminator value
        """
        return self._type

LbHttpRequestCookieCondition._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_http_request_cookie_condition', {
        'case_sensitive': type.OptionalType(type.BooleanType()),
        'cookie_name': type.OptionalType(type.StringType()),
        'cookie_value': type.OptionalType(type.StringType()),
        'match_type': type.OptionalType(type.StringType()),
        'inverse': type.OptionalType(type.BooleanType()),
        'type': type.StringType(),
    },
    LbHttpRequestCookieCondition,
    False,
    None))



class LbHttpRequestHeader(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'header_name': 'header_name',
                            'header_value': 'header_value',
                            }

    def __init__(self,
                 header_name=None,
                 header_value=None,
                ):
        """
        :type  header_name: :class:`str` or ``None``
        :param header_name: Name of HTTP request header
        :type  header_value: :class:`str` or ``None``
        :param header_value: Value of HTTP request header
        """
        self.header_name = header_name
        self.header_value = header_value
        VapiStruct.__init__(self)


LbHttpRequestHeader._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_http_request_header', {
        'header_name': type.OptionalType(type.StringType()),
        'header_value': type.OptionalType(type.StringType()),
    },
    LbHttpRequestHeader,
    False,
    None))



class LbHttpRequestHeaderCondition(VapiStruct):
    """
    This condition is used to match HTTP request messages by HTTP header
    fields. HTTP header fields are components of the header section of HTTP
    request and response messages. They define the operating parameters of an
    HTTP transaction. For example, Cookie, Authorization, User-Agent, etc. One
    condition can be used to match one header field, to match multiple header
    fields, multiple conditions must be specified. The match_type field defines
    how header_value field is used to match HTTP requests. The header_name
    field does not support match types.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LbHttpRequestHeaderCondition"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    MATCH_TYPE_STARTS_WITH = "STARTS_WITH"
    """


    """
    MATCH_TYPE_ENDS_WITH = "ENDS_WITH"
    """


    """
    MATCH_TYPE_EQUALS = "EQUALS"
    """


    """
    MATCH_TYPE_CONTAINS = "CONTAINS"
    """


    """
    MATCH_TYPE_REGEX = "REGEX"
    """


    """



    _canonical_to_pep_names = {
                            'case_sensitive': 'case_sensitive',
                            'header_name': 'header_name',
                            'header_value': 'header_value',
                            'match_type': 'match_type',
                            'inverse': 'inverse',
                            'type': 'type',
                            }

    def __init__(self,
                 case_sensitive=None,
                 header_name=None,
                 header_value=None,
                 match_type=None,
                 inverse=None,
                 type='LbHttpRequestHeaderCondition',
                ):
        """
        :type  case_sensitive: :class:`bool` or ``None``
        :param case_sensitive: If true, case is significant when comparing HTTP header value.
        :type  header_name: :class:`str` or ``None``
        :param header_name: Name of HTTP header
        :type  header_value: :class:`str` or ``None``
        :param header_value: Value of HTTP header
        :type  match_type: :class:`str` or ``None``
        :param match_type: Possible values are: 
            
            * :attr:`LbHttpRequestHeaderCondition.MATCH_TYPE_STARTS_WITH`
            * :attr:`LbHttpRequestHeaderCondition.MATCH_TYPE_ENDS_WITH`
            * :attr:`LbHttpRequestHeaderCondition.MATCH_TYPE_EQUALS`
            * :attr:`LbHttpRequestHeaderCondition.MATCH_TYPE_CONTAINS`
            * :attr:`LbHttpRequestHeaderCondition.MATCH_TYPE_REGEX`
            
             Match type of HTTP header value
        :type  inverse: :class:`bool` or ``None``
        :param inverse: A flag to indicate whether reverse the match result of this
            condition
        :type  type: :class:`str`
        :param type: Possible values are: 
            
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTMETHODCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTURICONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTURIARGUMENTSCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTVERSIONCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTHEADERCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTCOOKIECONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTBODYCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPRESPONSEHEADERCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBTCPHEADERCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBIPHEADERCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBVARIABLECONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPSSLCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBSSLSNICONDITION`
            
             Type of load balancer rule condition
        """
        self.case_sensitive = case_sensitive
        self.header_name = header_name
        self.header_value = header_value
        self.match_type = match_type
        self.inverse = inverse
        self._type = type
        VapiStruct.__init__(self)

    @property
    def type(self):
        """
        Return the discriminator value
        """
        return self._type

LbHttpRequestHeaderCondition._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_http_request_header_condition', {
        'case_sensitive': type.OptionalType(type.BooleanType()),
        'header_name': type.OptionalType(type.StringType()),
        'header_value': type.OptionalType(type.StringType()),
        'match_type': type.OptionalType(type.StringType()),
        'inverse': type.OptionalType(type.BooleanType()),
        'type': type.StringType(),
    },
    LbHttpRequestHeaderCondition,
    False,
    None))



class LbHttpRequestHeaderDeleteAction(VapiStruct):
    """
    This action is used to delete header fields of HTTP request messages at
    HTTP_REQUEST_REWRITE phase. One action can be used to delete all headers
    with same header name. To delete headers with different header names,
    multiple actions must be defined.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LbHttpRequestHeaderDeleteAction"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'header_name': 'header_name',
                            'type': 'type',
                            }

    def __init__(self,
                 header_name=None,
                 type='LbHttpRequestHeaderDeleteAction',
                ):
        """
        :type  header_name: :class:`str` or ``None``
        :param header_name: Name of a header field of HTTP request message
        :type  type: :class:`str`
        :param type: Possible values are: 
            
            * :attr:`LbRuleAction.TYPE_LBHTTPREQUESTURIREWRITEACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPREQUESTHEADERREWRITEACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPREJECTACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPREDIRECTACTION`
            * :attr:`LbRuleAction.TYPE_LBSELECTPOOLACTION`
            * :attr:`LbRuleAction.TYPE_LBSELECTSERVERACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPRESPONSEHEADERREWRITEACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPREQUESTHEADERDELETEACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPRESPONSEHEADERDELETEACTION`
            * :attr:`LbRuleAction.TYPE_LBVARIABLEASSIGNMENTACTION`
            * :attr:`LbRuleAction.TYPE_LBVARIABLEPERSISTENCEONACTION`
            * :attr:`LbRuleAction.TYPE_LBVARIABLEPERSISTENCELEARNACTION`
            * :attr:`LbRuleAction.TYPE_LBJWTAUTHACTION`
            * :attr:`LbRuleAction.TYPE_LBSSLMODESELECTIONACTION`
            * :attr:`LbRuleAction.TYPE_LBCONNECTIONDROPACTION`
            
             The property identifies the load balancer rule action type.
        """
        self.header_name = header_name
        self._type = type
        VapiStruct.__init__(self)

    @property
    def type(self):
        """
        Return the discriminator value
        """
        return self._type

LbHttpRequestHeaderDeleteAction._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_http_request_header_delete_action', {
        'header_name': type.OptionalType(type.StringType()),
        'type': type.StringType(),
    },
    LbHttpRequestHeaderDeleteAction,
    False,
    None))



class LbHttpRequestHeaderRewriteAction(VapiStruct):
    """
    This action is used to rewrite header fields of matched HTTP request
    messages to specified new values. One action can be used to rewrite one
    header field. To rewrite multiple header fields, multiple actions must be
    defined. Captured variables and built-in variables can be used in the
    header_value field, header_name field does not support variables.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LbHttpRequestHeaderRewriteAction"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'header_name': 'header_name',
                            'header_value': 'header_value',
                            'type': 'type',
                            }

    def __init__(self,
                 header_name=None,
                 header_value=None,
                 type='LbHttpRequestHeaderRewriteAction',
                ):
        """
        :type  header_name: :class:`str` or ``None``
        :param header_name: Name of HTTP request header
        :type  header_value: :class:`str` or ``None``
        :param header_value: Value of HTTP request header
        :type  type: :class:`str`
        :param type: Possible values are: 
            
            * :attr:`LbRuleAction.TYPE_LBHTTPREQUESTURIREWRITEACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPREQUESTHEADERREWRITEACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPREJECTACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPREDIRECTACTION`
            * :attr:`LbRuleAction.TYPE_LBSELECTPOOLACTION`
            * :attr:`LbRuleAction.TYPE_LBSELECTSERVERACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPRESPONSEHEADERREWRITEACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPREQUESTHEADERDELETEACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPRESPONSEHEADERDELETEACTION`
            * :attr:`LbRuleAction.TYPE_LBVARIABLEASSIGNMENTACTION`
            * :attr:`LbRuleAction.TYPE_LBVARIABLEPERSISTENCEONACTION`
            * :attr:`LbRuleAction.TYPE_LBVARIABLEPERSISTENCELEARNACTION`
            * :attr:`LbRuleAction.TYPE_LBJWTAUTHACTION`
            * :attr:`LbRuleAction.TYPE_LBSSLMODESELECTIONACTION`
            * :attr:`LbRuleAction.TYPE_LBCONNECTIONDROPACTION`
            
             The property identifies the load balancer rule action type.
        """
        self.header_name = header_name
        self.header_value = header_value
        self._type = type
        VapiStruct.__init__(self)

    @property
    def type(self):
        """
        Return the discriminator value
        """
        return self._type

LbHttpRequestHeaderRewriteAction._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_http_request_header_rewrite_action', {
        'header_name': type.OptionalType(type.StringType()),
        'header_value': type.OptionalType(type.StringType()),
        'type': type.StringType(),
    },
    LbHttpRequestHeaderRewriteAction,
    False,
    None))



class LbHttpRequestMethodCondition(VapiStruct):
    """
    This condition is used to match method of HTTP requests. If the method of
    an HTTP request is same as the method specified in this condition, the HTTP
    request match this condition. For example, if the method field is set to
    GET in this condition, any HTTP request with GET method matches the
    condition.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LbHttpRequestMethodCondition"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    METHOD_GET = "GET"
    """


    """
    METHOD_OPTIONS = "OPTIONS"
    """


    """
    METHOD_POST = "POST"
    """


    """
    METHOD_HEAD = "HEAD"
    """


    """
    METHOD_PUT = "PUT"
    """


    """



    _canonical_to_pep_names = {
                            'method': 'method',
                            'inverse': 'inverse',
                            'type': 'type',
                            }

    def __init__(self,
                 method=None,
                 inverse=None,
                 type='LbHttpRequestMethodCondition',
                ):
        """
        :type  method: :class:`str` or ``None``
        :param method: Possible values are: 
            
            * :attr:`LbHttpRequestMethodCondition.METHOD_GET`
            * :attr:`LbHttpRequestMethodCondition.METHOD_OPTIONS`
            * :attr:`LbHttpRequestMethodCondition.METHOD_POST`
            * :attr:`LbHttpRequestMethodCondition.METHOD_HEAD`
            * :attr:`LbHttpRequestMethodCondition.METHOD_PUT`
            
             Type of HTTP request method
        :type  inverse: :class:`bool` or ``None``
        :param inverse: A flag to indicate whether reverse the match result of this
            condition
        :type  type: :class:`str`
        :param type: Possible values are: 
            
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTMETHODCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTURICONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTURIARGUMENTSCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTVERSIONCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTHEADERCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTCOOKIECONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTBODYCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPRESPONSEHEADERCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBTCPHEADERCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBIPHEADERCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBVARIABLECONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPSSLCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBSSLSNICONDITION`
            
             Type of load balancer rule condition
        """
        self.method = method
        self.inverse = inverse
        self._type = type
        VapiStruct.__init__(self)

    @property
    def type(self):
        """
        Return the discriminator value
        """
        return self._type

LbHttpRequestMethodCondition._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_http_request_method_condition', {
        'method': type.OptionalType(type.StringType()),
        'inverse': type.OptionalType(type.BooleanType()),
        'type': type.StringType(),
    },
    LbHttpRequestMethodCondition,
    False,
    None))



class LbHttpRequestUriArgumentsCondition(VapiStruct):
    """
    This condition is used to match URI arguments aka query string of Http
    request messages, for example, in URI http://exaple.com?foo=1&bar=2, the
    \"foo=1&bar=2\" is the query string containing URI arguments. In an URI
    scheme, query string is indicated by the first question mark (\"?\")
    character and terminated by a number sign (\"#\") character or by the end
    of the URI. The uri_arguments field can be specified as a regular
    expression(Set match_type to REGEX). For example, \"foo=(?&lt;x&gt;\\d+)\".
    It matches HTTP requests whose URI arguments containing \"foo\", the value
    of foo contains only digits. And the value of foo is captured as $x which
    can be used in LbRuleAction fields which support variables.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LbHttpRequestUriArgumentsCondition"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    MATCH_TYPE_STARTS_WITH = "STARTS_WITH"
    """


    """
    MATCH_TYPE_ENDS_WITH = "ENDS_WITH"
    """


    """
    MATCH_TYPE_EQUALS = "EQUALS"
    """


    """
    MATCH_TYPE_CONTAINS = "CONTAINS"
    """


    """
    MATCH_TYPE_REGEX = "REGEX"
    """


    """



    _canonical_to_pep_names = {
                            'case_sensitive': 'case_sensitive',
                            'match_type': 'match_type',
                            'uri_arguments': 'uri_arguments',
                            'inverse': 'inverse',
                            'type': 'type',
                            }

    def __init__(self,
                 case_sensitive=None,
                 match_type=None,
                 uri_arguments=None,
                 inverse=None,
                 type='LbHttpRequestUriArgumentsCondition',
                ):
        """
        :type  case_sensitive: :class:`bool` or ``None``
        :param case_sensitive: If true, case is significant when comparing URI arguments.
        :type  match_type: :class:`str` or ``None``
        :param match_type: Possible values are: 
            
            * :attr:`LbHttpRequestUriArgumentsCondition.MATCH_TYPE_STARTS_WITH`
            * :attr:`LbHttpRequestUriArgumentsCondition.MATCH_TYPE_ENDS_WITH`
            * :attr:`LbHttpRequestUriArgumentsCondition.MATCH_TYPE_EQUALS`
            * :attr:`LbHttpRequestUriArgumentsCondition.MATCH_TYPE_CONTAINS`
            * :attr:`LbHttpRequestUriArgumentsCondition.MATCH_TYPE_REGEX`
            
             Match type of URI arguments
        :type  uri_arguments: :class:`str` or ``None``
        :param uri_arguments: URI arguments, aka query string of URI.
        :type  inverse: :class:`bool` or ``None``
        :param inverse: A flag to indicate whether reverse the match result of this
            condition
        :type  type: :class:`str`
        :param type: Possible values are: 
            
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTMETHODCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTURICONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTURIARGUMENTSCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTVERSIONCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTHEADERCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTCOOKIECONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTBODYCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPRESPONSEHEADERCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBTCPHEADERCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBIPHEADERCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBVARIABLECONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPSSLCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBSSLSNICONDITION`
            
             Type of load balancer rule condition
        """
        self.case_sensitive = case_sensitive
        self.match_type = match_type
        self.uri_arguments = uri_arguments
        self.inverse = inverse
        self._type = type
        VapiStruct.__init__(self)

    @property
    def type(self):
        """
        Return the discriminator value
        """
        return self._type

LbHttpRequestUriArgumentsCondition._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_http_request_uri_arguments_condition', {
        'case_sensitive': type.OptionalType(type.BooleanType()),
        'match_type': type.OptionalType(type.StringType()),
        'uri_arguments': type.OptionalType(type.StringType()),
        'inverse': type.OptionalType(type.BooleanType()),
        'type': type.StringType(),
    },
    LbHttpRequestUriArgumentsCondition,
    False,
    None))



class LbHttpRequestUriCondition(VapiStruct):
    """
    This condition is used to match URIs(Uniform Resource Identifier) of HTTP
    request messages. The URI field can be specified as a regular expression.
    If an HTTP request message is requesting an URI which matches specified
    regular expression, it matches the condition. The syntax of whole URI looks
    like this:
    scheme:[//[user[:password]\\\\@]host[:port]][/path][?query][#fragment] This
    condition matches only the path part of entire URI. When match_type field
    is specified as REGEX, the uri field is used as a regular expression to
    match URI path of HTTP requests. For example, to match any URI that has
    \"/image/\" or \"/images/\", uri field can be specified as:
    \"/image[s]?/\". Named capturing groups can be used in the uri field to
    capture substrings of matched URIs and store them in variables for use in
    LbRuleAction. For example, specify uri field as:
    \"/news/(?&lt;year&gt;\\d+)/(?&lt;month&gt;\\d+)/(?&lt;article&gt;.\*)\" If
    the URI path is /articles/news/2017/06/xyz.html, then substring \"2017\" is
    captured in variable year, \"06\" is captured in variable month, and
    \"xyz.html\" is captured in variable article. These variables can then be
    used in an LbRuleAction field which supports variables, such as uri field
    of LbHttpRequestUriRewriteAction. For example, set the uri field of
    LbHttpRequestUriRewriteAction as: \"/articles/news/$year-$month-$article\"
    Then the URI path /articles/news/2017/06/xyz.html is rewritten to:
    \"/articles/news/2017-06-xyz.html\"

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LbHttpRequestUriCondition"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    MATCH_TYPE_STARTS_WITH = "STARTS_WITH"
    """


    """
    MATCH_TYPE_ENDS_WITH = "ENDS_WITH"
    """


    """
    MATCH_TYPE_EQUALS = "EQUALS"
    """


    """
    MATCH_TYPE_CONTAINS = "CONTAINS"
    """


    """
    MATCH_TYPE_REGEX = "REGEX"
    """


    """



    _canonical_to_pep_names = {
                            'case_sensitive': 'case_sensitive',
                            'match_type': 'match_type',
                            'uri': 'uri',
                            'inverse': 'inverse',
                            'type': 'type',
                            }

    def __init__(self,
                 case_sensitive=None,
                 match_type=None,
                 uri=None,
                 inverse=None,
                 type='LbHttpRequestUriCondition',
                ):
        """
        :type  case_sensitive: :class:`bool` or ``None``
        :param case_sensitive: If true, case is significant when comparing URI.
        :type  match_type: :class:`str` or ``None``
        :param match_type: Possible values are: 
            
            * :attr:`LbHttpRequestUriCondition.MATCH_TYPE_STARTS_WITH`
            * :attr:`LbHttpRequestUriCondition.MATCH_TYPE_ENDS_WITH`
            * :attr:`LbHttpRequestUriCondition.MATCH_TYPE_EQUALS`
            * :attr:`LbHttpRequestUriCondition.MATCH_TYPE_CONTAINS`
            * :attr:`LbHttpRequestUriCondition.MATCH_TYPE_REGEX`
            
             Match type of URI
        :type  uri: :class:`str` or ``None``
        :param uri: A string used to identify resource
        :type  inverse: :class:`bool` or ``None``
        :param inverse: A flag to indicate whether reverse the match result of this
            condition
        :type  type: :class:`str`
        :param type: Possible values are: 
            
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTMETHODCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTURICONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTURIARGUMENTSCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTVERSIONCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTHEADERCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTCOOKIECONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTBODYCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPRESPONSEHEADERCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBTCPHEADERCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBIPHEADERCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBVARIABLECONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPSSLCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBSSLSNICONDITION`
            
             Type of load balancer rule condition
        """
        self.case_sensitive = case_sensitive
        self.match_type = match_type
        self.uri = uri
        self.inverse = inverse
        self._type = type
        VapiStruct.__init__(self)

    @property
    def type(self):
        """
        Return the discriminator value
        """
        return self._type

LbHttpRequestUriCondition._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_http_request_uri_condition', {
        'case_sensitive': type.OptionalType(type.BooleanType()),
        'match_type': type.OptionalType(type.StringType()),
        'uri': type.OptionalType(type.StringType()),
        'inverse': type.OptionalType(type.BooleanType()),
        'type': type.StringType(),
    },
    LbHttpRequestUriCondition,
    False,
    None))



class LbHttpRequestUriRewriteAction(VapiStruct):
    """
    This action is used to rewrite URIs in matched HTTP request messages.
    Specify the uri and uri_arguments fields in this condition to rewrite the
    matched HTTP request message's URI and URI arguments to the new values.
    Full URI scheme of HTTP messages have following syntax:
    scheme:[//[user[:password]\\\\@]host[:port]][/path][?query][#fragment] The
    uri field of this action is used to rewrite the /path part in above scheme.
    And the uri_arguments field is used to rewrite the query part. Captured
    variables and built-in variables can be used in the uri and uri_arguments
    fields. Check the example in LbRuleAction to see how to use variables in
    this action.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LbHttpRequestUriRewriteAction"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'uri': 'uri',
                            'uri_arguments': 'uri_arguments',
                            'type': 'type',
                            }

    def __init__(self,
                 uri=None,
                 uri_arguments=None,
                 type='LbHttpRequestUriRewriteAction',
                ):
        """
        :type  uri: :class:`str` or ``None``
        :param uri: URI of HTTP request
        :type  uri_arguments: :class:`str` or ``None``
        :param uri_arguments: Query string of URI, typically contains key value pairs, for
            example: foo1=bar1&foo2=bar2
        :type  type: :class:`str`
        :param type: Possible values are: 
            
            * :attr:`LbRuleAction.TYPE_LBHTTPREQUESTURIREWRITEACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPREQUESTHEADERREWRITEACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPREJECTACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPREDIRECTACTION`
            * :attr:`LbRuleAction.TYPE_LBSELECTPOOLACTION`
            * :attr:`LbRuleAction.TYPE_LBSELECTSERVERACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPRESPONSEHEADERREWRITEACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPREQUESTHEADERDELETEACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPRESPONSEHEADERDELETEACTION`
            * :attr:`LbRuleAction.TYPE_LBVARIABLEASSIGNMENTACTION`
            * :attr:`LbRuleAction.TYPE_LBVARIABLEPERSISTENCEONACTION`
            * :attr:`LbRuleAction.TYPE_LBVARIABLEPERSISTENCELEARNACTION`
            * :attr:`LbRuleAction.TYPE_LBJWTAUTHACTION`
            * :attr:`LbRuleAction.TYPE_LBSSLMODESELECTIONACTION`
            * :attr:`LbRuleAction.TYPE_LBCONNECTIONDROPACTION`
            
             The property identifies the load balancer rule action type.
        """
        self.uri = uri
        self.uri_arguments = uri_arguments
        self._type = type
        VapiStruct.__init__(self)

    @property
    def type(self):
        """
        Return the discriminator value
        """
        return self._type

LbHttpRequestUriRewriteAction._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_http_request_uri_rewrite_action', {
        'uri': type.OptionalType(type.StringType()),
        'uri_arguments': type.OptionalType(type.StringType()),
        'type': type.StringType(),
    },
    LbHttpRequestUriRewriteAction,
    False,
    None))



class LbHttpRequestVersionCondition(VapiStruct):
    """
    This condition is used to match the HTTP protocol version of the HTTP
    request messages.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LbHttpRequestVersionCondition"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    VERSION_1_0 = "HTTP_VERSION_1_0"
    """


    """
    VERSION_1_1 = "HTTP_VERSION_1_1"
    """


    """
    VERSION_2_0 = "HTTP_VERSION_2_0"
    """


    """



    _canonical_to_pep_names = {
                            'version': 'version',
                            'inverse': 'inverse',
                            'type': 'type',
                            }

    def __init__(self,
                 version=None,
                 inverse=None,
                 type='LbHttpRequestVersionCondition',
                ):
        """
        :type  version: :class:`str` or ``None``
        :param version: Possible values are: 
            
            * :attr:`LbHttpRequestVersionCondition.VERSION__1_0`
            * :attr:`LbHttpRequestVersionCondition.VERSION__1_1`
            * :attr:`LbHttpRequestVersionCondition.VERSION__2_0`
            
             HTTP version
        :type  inverse: :class:`bool` or ``None``
        :param inverse: A flag to indicate whether reverse the match result of this
            condition
        :type  type: :class:`str`
        :param type: Possible values are: 
            
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTMETHODCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTURICONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTURIARGUMENTSCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTVERSIONCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTHEADERCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTCOOKIECONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTBODYCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPRESPONSEHEADERCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBTCPHEADERCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBIPHEADERCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBVARIABLECONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPSSLCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBSSLSNICONDITION`
            
             Type of load balancer rule condition
        """
        self.version = version
        self.inverse = inverse
        self._type = type
        VapiStruct.__init__(self)

    @property
    def type(self):
        """
        Return the discriminator value
        """
        return self._type

LbHttpRequestVersionCondition._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_http_request_version_condition', {
        'version': type.OptionalType(type.StringType()),
        'inverse': type.OptionalType(type.BooleanType()),
        'type': type.StringType(),
    },
    LbHttpRequestVersionCondition,
    False,
    None))



class LbHttpResponseHeaderCondition(VapiStruct):
    """
    This condition is used to match HTTP response messages from backend servers
    by HTTP header fields. HTTP header fields are components of the header
    section of HTTP request and response messages. They define the operating
    parameters of an HTTP transaction. For example, Cookie, Authorization,
    User-Agent, etc. One condition can be used to match one header field, to
    match multiple header fields, multiple conditions must be specified. The
    match_type field defines how header_value field is used to match HTTP
    responses. The header_name field does not support match types.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LbHttpResponseHeaderCondition"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    MATCH_TYPE_STARTS_WITH = "STARTS_WITH"
    """


    """
    MATCH_TYPE_ENDS_WITH = "ENDS_WITH"
    """


    """
    MATCH_TYPE_EQUALS = "EQUALS"
    """


    """
    MATCH_TYPE_CONTAINS = "CONTAINS"
    """


    """
    MATCH_TYPE_REGEX = "REGEX"
    """


    """



    _canonical_to_pep_names = {
                            'case_sensitive': 'case_sensitive',
                            'header_name': 'header_name',
                            'header_value': 'header_value',
                            'match_type': 'match_type',
                            'inverse': 'inverse',
                            'type': 'type',
                            }

    def __init__(self,
                 case_sensitive=None,
                 header_name=None,
                 header_value=None,
                 match_type=None,
                 inverse=None,
                 type='LbHttpResponseHeaderCondition',
                ):
        """
        :type  case_sensitive: :class:`bool` or ``None``
        :param case_sensitive: If true, case is significant when comparing HTTP header value.
        :type  header_name: :class:`str` or ``None``
        :param header_name: Name of HTTP header field
        :type  header_value: :class:`str` or ``None``
        :param header_value: Value of HTTP header field
        :type  match_type: :class:`str` or ``None``
        :param match_type: Possible values are: 
            
            * :attr:`LbHttpResponseHeaderCondition.MATCH_TYPE_STARTS_WITH`
            * :attr:`LbHttpResponseHeaderCondition.MATCH_TYPE_ENDS_WITH`
            * :attr:`LbHttpResponseHeaderCondition.MATCH_TYPE_EQUALS`
            * :attr:`LbHttpResponseHeaderCondition.MATCH_TYPE_CONTAINS`
            * :attr:`LbHttpResponseHeaderCondition.MATCH_TYPE_REGEX`
            
             Match type of HTTP header value
        :type  inverse: :class:`bool` or ``None``
        :param inverse: A flag to indicate whether reverse the match result of this
            condition
        :type  type: :class:`str`
        :param type: Possible values are: 
            
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTMETHODCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTURICONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTURIARGUMENTSCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTVERSIONCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTHEADERCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTCOOKIECONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTBODYCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPRESPONSEHEADERCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBTCPHEADERCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBIPHEADERCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBVARIABLECONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPSSLCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBSSLSNICONDITION`
            
             Type of load balancer rule condition
        """
        self.case_sensitive = case_sensitive
        self.header_name = header_name
        self.header_value = header_value
        self.match_type = match_type
        self.inverse = inverse
        self._type = type
        VapiStruct.__init__(self)

    @property
    def type(self):
        """
        Return the discriminator value
        """
        return self._type

LbHttpResponseHeaderCondition._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_http_response_header_condition', {
        'case_sensitive': type.OptionalType(type.BooleanType()),
        'header_name': type.OptionalType(type.StringType()),
        'header_value': type.OptionalType(type.StringType()),
        'match_type': type.OptionalType(type.StringType()),
        'inverse': type.OptionalType(type.BooleanType()),
        'type': type.StringType(),
    },
    LbHttpResponseHeaderCondition,
    False,
    None))



class LbHttpResponseHeaderDeleteAction(VapiStruct):
    """
    This action is used to delete header fields of HTTP response messages at
    HTTP_RESPONSE_REWRITE phase. One action can be used to delete allgi headers
    with same header name. To delete headers with different header names,
    multiple actions must be defined

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LbHttpResponseHeaderDeleteAction"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'header_name': 'header_name',
                            'type': 'type',
                            }

    def __init__(self,
                 header_name=None,
                 type='LbHttpResponseHeaderDeleteAction',
                ):
        """
        :type  header_name: :class:`str` or ``None``
        :param header_name: Name of a header field of HTTP response message
        :type  type: :class:`str`
        :param type: Possible values are: 
            
            * :attr:`LbRuleAction.TYPE_LBHTTPREQUESTURIREWRITEACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPREQUESTHEADERREWRITEACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPREJECTACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPREDIRECTACTION`
            * :attr:`LbRuleAction.TYPE_LBSELECTPOOLACTION`
            * :attr:`LbRuleAction.TYPE_LBSELECTSERVERACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPRESPONSEHEADERREWRITEACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPREQUESTHEADERDELETEACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPRESPONSEHEADERDELETEACTION`
            * :attr:`LbRuleAction.TYPE_LBVARIABLEASSIGNMENTACTION`
            * :attr:`LbRuleAction.TYPE_LBVARIABLEPERSISTENCEONACTION`
            * :attr:`LbRuleAction.TYPE_LBVARIABLEPERSISTENCELEARNACTION`
            * :attr:`LbRuleAction.TYPE_LBJWTAUTHACTION`
            * :attr:`LbRuleAction.TYPE_LBSSLMODESELECTIONACTION`
            * :attr:`LbRuleAction.TYPE_LBCONNECTIONDROPACTION`
            
             The property identifies the load balancer rule action type.
        """
        self.header_name = header_name
        self._type = type
        VapiStruct.__init__(self)

    @property
    def type(self):
        """
        Return the discriminator value
        """
        return self._type

LbHttpResponseHeaderDeleteAction._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_http_response_header_delete_action', {
        'header_name': type.OptionalType(type.StringType()),
        'type': type.StringType(),
    },
    LbHttpResponseHeaderDeleteAction,
    False,
    None))



class LbHttpResponseHeaderRewriteAction(VapiStruct):
    """
    This action is used to rewrite header fields of HTTP response messages to
    specified new values at HTTP_RESPONSE_REWRITE phase. One action can be used
    to rewrite one header field. To rewrite multiple header fields, multiple
    actions must be defined. Captured variables and built-in variables can be
    used in the header_value field, header_name field does not support
    variables.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LbHttpResponseHeaderRewriteAction"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'header_name': 'header_name',
                            'header_value': 'header_value',
                            'type': 'type',
                            }

    def __init__(self,
                 header_name=None,
                 header_value=None,
                 type='LbHttpResponseHeaderRewriteAction',
                ):
        """
        :type  header_name: :class:`str` or ``None``
        :param header_name: Name of a header field of HTTP request message
        :type  header_value: :class:`str` or ``None``
        :param header_value: Value of header field
        :type  type: :class:`str`
        :param type: Possible values are: 
            
            * :attr:`LbRuleAction.TYPE_LBHTTPREQUESTURIREWRITEACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPREQUESTHEADERREWRITEACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPREJECTACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPREDIRECTACTION`
            * :attr:`LbRuleAction.TYPE_LBSELECTPOOLACTION`
            * :attr:`LbRuleAction.TYPE_LBSELECTSERVERACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPRESPONSEHEADERREWRITEACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPREQUESTHEADERDELETEACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPRESPONSEHEADERDELETEACTION`
            * :attr:`LbRuleAction.TYPE_LBVARIABLEASSIGNMENTACTION`
            * :attr:`LbRuleAction.TYPE_LBVARIABLEPERSISTENCEONACTION`
            * :attr:`LbRuleAction.TYPE_LBVARIABLEPERSISTENCELEARNACTION`
            * :attr:`LbRuleAction.TYPE_LBJWTAUTHACTION`
            * :attr:`LbRuleAction.TYPE_LBSSLMODESELECTIONACTION`
            * :attr:`LbRuleAction.TYPE_LBCONNECTIONDROPACTION`
            
             The property identifies the load balancer rule action type.
        """
        self.header_name = header_name
        self.header_value = header_value
        self._type = type
        VapiStruct.__init__(self)

    @property
    def type(self):
        """
        Return the discriminator value
        """
        return self._type

LbHttpResponseHeaderRewriteAction._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_http_response_header_rewrite_action', {
        'header_name': type.OptionalType(type.StringType()),
        'header_value': type.OptionalType(type.StringType()),
        'type': type.StringType(),
    },
    LbHttpResponseHeaderRewriteAction,
    False,
    None))



class LbHttpSslCondition(VapiStruct):
    """
    This condition is used to match SSL handshake and SSL connection at all
    phases.If multiple properties are configured, the rule is considered a
    match when all the configured properties are matched.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LbHttpSslCondition"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    CLIENT_SUPPORTED_SSL_CIPHERS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 = "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256"
    """


    """
    CLIENT_SUPPORTED_SSL_CIPHERS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 = "TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384"
    """


    """
    CLIENT_SUPPORTED_SSL_CIPHERS_ECDHE_RSA_WITH_AES_256_CBC_SHA = "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA"
    """


    """
    CLIENT_SUPPORTED_SSL_CIPHERS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA = "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA"
    """


    """
    CLIENT_SUPPORTED_SSL_CIPHERS_ECDH_ECDSA_WITH_AES_256_CBC_SHA = "TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA"
    """


    """
    CLIENT_SUPPORTED_SSL_CIPHERS_ECDH_RSA_WITH_AES_256_CBC_SHA = "TLS_ECDH_RSA_WITH_AES_256_CBC_SHA"
    """


    """
    CLIENT_SUPPORTED_SSL_CIPHERS_RSA_WITH_AES_256_CBC_SHA = "TLS_RSA_WITH_AES_256_CBC_SHA"
    """


    """
    CLIENT_SUPPORTED_SSL_CIPHERS_RSA_WITH_AES_128_CBC_SHA = "TLS_RSA_WITH_AES_128_CBC_SHA"
    """


    """
    CLIENT_SUPPORTED_SSL_CIPHERS_RSA_WITH_3DES_EDE_CBC_SHA = "TLS_RSA_WITH_3DES_EDE_CBC_SHA"
    """


    """
    CLIENT_SUPPORTED_SSL_CIPHERS_ECDHE_RSA_WITH_AES_128_CBC_SHA = "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA"
    """


    """
    CLIENT_SUPPORTED_SSL_CIPHERS_ECDHE_RSA_WITH_AES_128_CBC_SHA256 = "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256"
    """


    """
    CLIENT_SUPPORTED_SSL_CIPHERS_ECDHE_RSA_WITH_AES_256_CBC_SHA384 = "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384"
    """


    """
    CLIENT_SUPPORTED_SSL_CIPHERS_RSA_WITH_AES_128_CBC_SHA256 = "TLS_RSA_WITH_AES_128_CBC_SHA256"
    """


    """
    CLIENT_SUPPORTED_SSL_CIPHERS_RSA_WITH_AES_128_GCM_SHA256 = "TLS_RSA_WITH_AES_128_GCM_SHA256"
    """


    """
    CLIENT_SUPPORTED_SSL_CIPHERS_RSA_WITH_AES_256_CBC_SHA256 = "TLS_RSA_WITH_AES_256_CBC_SHA256"
    """


    """
    CLIENT_SUPPORTED_SSL_CIPHERS_RSA_WITH_AES_256_GCM_SHA384 = "TLS_RSA_WITH_AES_256_GCM_SHA384"
    """


    """
    CLIENT_SUPPORTED_SSL_CIPHERS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA = "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA"
    """


    """
    CLIENT_SUPPORTED_SSL_CIPHERS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256 = "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256"
    """


    """
    CLIENT_SUPPORTED_SSL_CIPHERS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 = "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256"
    """


    """
    CLIENT_SUPPORTED_SSL_CIPHERS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384 = "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384"
    """


    """
    CLIENT_SUPPORTED_SSL_CIPHERS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384 = "TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384"
    """


    """
    CLIENT_SUPPORTED_SSL_CIPHERS_ECDH_ECDSA_WITH_AES_128_CBC_SHA = "TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA"
    """


    """
    CLIENT_SUPPORTED_SSL_CIPHERS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256 = "TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256"
    """


    """
    CLIENT_SUPPORTED_SSL_CIPHERS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256 = "TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256"
    """


    """
    CLIENT_SUPPORTED_SSL_CIPHERS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384 = "TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384"
    """


    """
    CLIENT_SUPPORTED_SSL_CIPHERS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384 = "TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384"
    """


    """
    CLIENT_SUPPORTED_SSL_CIPHERS_ECDH_RSA_WITH_AES_128_CBC_SHA = "TLS_ECDH_RSA_WITH_AES_128_CBC_SHA"
    """


    """
    CLIENT_SUPPORTED_SSL_CIPHERS_ECDH_RSA_WITH_AES_128_CBC_SHA256 = "TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256"
    """


    """
    CLIENT_SUPPORTED_SSL_CIPHERS_ECDH_RSA_WITH_AES_128_GCM_SHA256 = "TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256"
    """


    """
    CLIENT_SUPPORTED_SSL_CIPHERS_ECDH_RSA_WITH_AES_256_CBC_SHA384 = "TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384"
    """


    """
    CLIENT_SUPPORTED_SSL_CIPHERS_ECDH_RSA_WITH_AES_256_GCM_SHA384 = "TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384"
    """


    """
    SESSION_REUSED_IGNORE = "IGNORE"
    """


    """
    SESSION_REUSED_REUSED = "REUSED"
    """


    """
    SESSION_REUSED_NEW = "NEW"
    """


    """
    USED_PROTOCOL_SSL_V2 = "SSL_V2"
    """


    """
    USED_PROTOCOL_SSL_V3 = "SSL_V3"
    """


    """
    USED_PROTOCOL_TLS_V1 = "TLS_V1"
    """


    """
    USED_PROTOCOL_TLS_V1_1 = "TLS_V1_1"
    """


    """
    USED_PROTOCOL_TLS_V1_2 = "TLS_V1_2"
    """


    """
    USED_SSL_CIPHER_ECDHE_RSA_WITH_AES_128_GCM_SHA256 = "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256"
    """


    """
    USED_SSL_CIPHER_ECDHE_RSA_WITH_AES_256_GCM_SHA384 = "TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384"
    """


    """
    USED_SSL_CIPHER_ECDHE_RSA_WITH_AES_256_CBC_SHA = "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA"
    """


    """
    USED_SSL_CIPHER_ECDHE_ECDSA_WITH_AES_256_CBC_SHA = "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA"
    """


    """
    USED_SSL_CIPHER_ECDH_ECDSA_WITH_AES_256_CBC_SHA = "TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA"
    """


    """
    USED_SSL_CIPHER_ECDH_RSA_WITH_AES_256_CBC_SHA = "TLS_ECDH_RSA_WITH_AES_256_CBC_SHA"
    """


    """
    USED_SSL_CIPHER_RSA_WITH_AES_256_CBC_SHA = "TLS_RSA_WITH_AES_256_CBC_SHA"
    """


    """
    USED_SSL_CIPHER_RSA_WITH_AES_128_CBC_SHA = "TLS_RSA_WITH_AES_128_CBC_SHA"
    """


    """
    USED_SSL_CIPHER_RSA_WITH_3DES_EDE_CBC_SHA = "TLS_RSA_WITH_3DES_EDE_CBC_SHA"
    """


    """
    USED_SSL_CIPHER_ECDHE_RSA_WITH_AES_128_CBC_SHA = "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA"
    """


    """
    USED_SSL_CIPHER_ECDHE_RSA_WITH_AES_128_CBC_SHA256 = "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256"
    """


    """
    USED_SSL_CIPHER_ECDHE_RSA_WITH_AES_256_CBC_SHA384 = "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384"
    """


    """
    USED_SSL_CIPHER_RSA_WITH_AES_128_CBC_SHA256 = "TLS_RSA_WITH_AES_128_CBC_SHA256"
    """


    """
    USED_SSL_CIPHER_RSA_WITH_AES_128_GCM_SHA256 = "TLS_RSA_WITH_AES_128_GCM_SHA256"
    """


    """
    USED_SSL_CIPHER_RSA_WITH_AES_256_CBC_SHA256 = "TLS_RSA_WITH_AES_256_CBC_SHA256"
    """


    """
    USED_SSL_CIPHER_RSA_WITH_AES_256_GCM_SHA384 = "TLS_RSA_WITH_AES_256_GCM_SHA384"
    """


    """
    USED_SSL_CIPHER_ECDHE_ECDSA_WITH_AES_128_CBC_SHA = "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA"
    """


    """
    USED_SSL_CIPHER_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256 = "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256"
    """


    """
    USED_SSL_CIPHER_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 = "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256"
    """


    """
    USED_SSL_CIPHER_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384 = "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384"
    """


    """
    USED_SSL_CIPHER_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384 = "TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384"
    """


    """
    USED_SSL_CIPHER_ECDH_ECDSA_WITH_AES_128_CBC_SHA = "TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA"
    """


    """
    USED_SSL_CIPHER_ECDH_ECDSA_WITH_AES_128_CBC_SHA256 = "TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256"
    """


    """
    USED_SSL_CIPHER_ECDH_ECDSA_WITH_AES_128_GCM_SHA256 = "TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256"
    """


    """
    USED_SSL_CIPHER_ECDH_ECDSA_WITH_AES_256_CBC_SHA384 = "TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384"
    """


    """
    USED_SSL_CIPHER_ECDH_ECDSA_WITH_AES_256_GCM_SHA384 = "TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384"
    """


    """
    USED_SSL_CIPHER_ECDH_RSA_WITH_AES_128_CBC_SHA = "TLS_ECDH_RSA_WITH_AES_128_CBC_SHA"
    """


    """
    USED_SSL_CIPHER_ECDH_RSA_WITH_AES_128_CBC_SHA256 = "TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256"
    """


    """
    USED_SSL_CIPHER_ECDH_RSA_WITH_AES_128_GCM_SHA256 = "TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256"
    """


    """
    USED_SSL_CIPHER_ECDH_RSA_WITH_AES_256_CBC_SHA384 = "TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384"
    """


    """
    USED_SSL_CIPHER_ECDH_RSA_WITH_AES_256_GCM_SHA384 = "TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384"
    """


    """



    _canonical_to_pep_names = {
                            'client_certificate_issuer_dn': 'client_certificate_issuer_dn',
                            'client_certificate_subject_dn': 'client_certificate_subject_dn',
                            'client_supported_ssl_ciphers': 'client_supported_ssl_ciphers',
                            'session_reused': 'session_reused',
                            'used_protocol': 'used_protocol',
                            'used_ssl_cipher': 'used_ssl_cipher',
                            'inverse': 'inverse',
                            'type': 'type',
                            }

    def __init__(self,
                 client_certificate_issuer_dn=None,
                 client_certificate_subject_dn=None,
                 client_supported_ssl_ciphers=None,
                 session_reused=None,
                 used_protocol=None,
                 used_ssl_cipher=None,
                 inverse=None,
                 type='LbHttpSslCondition',
                ):
        """
        :type  client_certificate_issuer_dn: :class:`LbClientCertificateIssuerDnCondition` or ``None``
        :param client_certificate_issuer_dn: The issuer DN match condition of the client certificate for an
            established SSL connection
        :type  client_certificate_subject_dn: :class:`LbClientCertificateSubjectDnCondition` or ``None``
        :param client_certificate_subject_dn: The subject DN match condition of the client certificate for an
            established SSL connection
        :type  client_supported_ssl_ciphers: :class:`list` of :class:`str` or ``None``
        :param client_supported_ssl_ciphers: Possible values are: 
            
            *
              :attr:`LbHttpSslCondition.CLIENT_SUPPORTED_SSL_CIPHERS_ECDHE_RSA_WITH_AES_128_GCM_SHA256`
            *
              :attr:`LbHttpSslCondition.CLIENT_SUPPORTED_SSL_CIPHERS_ECDHE_RSA_WITH_AES_256_GCM_SHA384`
            *
              :attr:`LbHttpSslCondition.CLIENT_SUPPORTED_SSL_CIPHERS_ECDHE_RSA_WITH_AES_256_CBC_SHA`
            *
              :attr:`LbHttpSslCondition.CLIENT_SUPPORTED_SSL_CIPHERS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA`
            *
              :attr:`LbHttpSslCondition.CLIENT_SUPPORTED_SSL_CIPHERS_ECDH_ECDSA_WITH_AES_256_CBC_SHA`
            *
              :attr:`LbHttpSslCondition.CLIENT_SUPPORTED_SSL_CIPHERS_ECDH_RSA_WITH_AES_256_CBC_SHA`
            *
              :attr:`LbHttpSslCondition.CLIENT_SUPPORTED_SSL_CIPHERS_RSA_WITH_AES_256_CBC_SHA`
            *
              :attr:`LbHttpSslCondition.CLIENT_SUPPORTED_SSL_CIPHERS_RSA_WITH_AES_128_CBC_SHA`
            *
              :attr:`LbHttpSslCondition.CLIENT_SUPPORTED_SSL_CIPHERS_RSA_WITH_3DES_EDE_CBC_SHA`
            *
              :attr:`LbHttpSslCondition.CLIENT_SUPPORTED_SSL_CIPHERS_ECDHE_RSA_WITH_AES_128_CBC_SHA`
            *
              :attr:`LbHttpSslCondition.CLIENT_SUPPORTED_SSL_CIPHERS_ECDHE_RSA_WITH_AES_128_CBC_SHA256`
            *
              :attr:`LbHttpSslCondition.CLIENT_SUPPORTED_SSL_CIPHERS_ECDHE_RSA_WITH_AES_256_CBC_SHA384`
            *
              :attr:`LbHttpSslCondition.CLIENT_SUPPORTED_SSL_CIPHERS_RSA_WITH_AES_128_CBC_SHA256`
            *
              :attr:`LbHttpSslCondition.CLIENT_SUPPORTED_SSL_CIPHERS_RSA_WITH_AES_128_GCM_SHA256`
            *
              :attr:`LbHttpSslCondition.CLIENT_SUPPORTED_SSL_CIPHERS_RSA_WITH_AES_256_CBC_SHA256`
            *
              :attr:`LbHttpSslCondition.CLIENT_SUPPORTED_SSL_CIPHERS_RSA_WITH_AES_256_GCM_SHA384`
            *
              :attr:`LbHttpSslCondition.CLIENT_SUPPORTED_SSL_CIPHERS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA`
            *
              :attr:`LbHttpSslCondition.CLIENT_SUPPORTED_SSL_CIPHERS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256`
            *
              :attr:`LbHttpSslCondition.CLIENT_SUPPORTED_SSL_CIPHERS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256`
            *
              :attr:`LbHttpSslCondition.CLIENT_SUPPORTED_SSL_CIPHERS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384`
            *
              :attr:`LbHttpSslCondition.CLIENT_SUPPORTED_SSL_CIPHERS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384`
            *
              :attr:`LbHttpSslCondition.CLIENT_SUPPORTED_SSL_CIPHERS_ECDH_ECDSA_WITH_AES_128_CBC_SHA`
            *
              :attr:`LbHttpSslCondition.CLIENT_SUPPORTED_SSL_CIPHERS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256`
            *
              :attr:`LbHttpSslCondition.CLIENT_SUPPORTED_SSL_CIPHERS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256`
            *
              :attr:`LbHttpSslCondition.CLIENT_SUPPORTED_SSL_CIPHERS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384`
            *
              :attr:`LbHttpSslCondition.CLIENT_SUPPORTED_SSL_CIPHERS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384`
            *
              :attr:`LbHttpSslCondition.CLIENT_SUPPORTED_SSL_CIPHERS_ECDH_RSA_WITH_AES_128_CBC_SHA`
            *
              :attr:`LbHttpSslCondition.CLIENT_SUPPORTED_SSL_CIPHERS_ECDH_RSA_WITH_AES_128_CBC_SHA256`
            *
              :attr:`LbHttpSslCondition.CLIENT_SUPPORTED_SSL_CIPHERS_ECDH_RSA_WITH_AES_128_GCM_SHA256`
            *
              :attr:`LbHttpSslCondition.CLIENT_SUPPORTED_SSL_CIPHERS_ECDH_RSA_WITH_AES_256_CBC_SHA384`
            *
              :attr:`LbHttpSslCondition.CLIENT_SUPPORTED_SSL_CIPHERS_ECDH_RSA_WITH_AES_256_GCM_SHA384`
            
             Cipher list which supported by client
        :type  session_reused: :class:`str` or ``None``
        :param session_reused: Possible values are: 
            
            * :attr:`LbHttpSslCondition.SESSION_REUSED_IGNORE`
            * :attr:`LbHttpSslCondition.SESSION_REUSED_REUSED`
            * :attr:`LbHttpSslCondition.SESSION_REUSED_NEW`
            
             The type of SSL session reused
        :type  used_protocol: :class:`str` or ``None``
        :param used_protocol: Possible values are: 
            
            * :attr:`LbHttpSslCondition.USED_PROTOCOL_SSL_V2`
            * :attr:`LbHttpSslCondition.USED_PROTOCOL_SSL_V3`
            * :attr:`LbHttpSslCondition.USED_PROTOCOL_TLS_V1`
            * :attr:`LbHttpSslCondition.USED_PROTOCOL_TLS_V1_1`
            * :attr:`LbHttpSslCondition.USED_PROTOCOL_TLS_V1_2`
            
             Protocol of an established SSL connection
        :type  used_ssl_cipher: :class:`str` or ``None``
        :param used_ssl_cipher: Possible values are: 
            
            *
              :attr:`LbHttpSslCondition.USED_SSL_CIPHER_ECDHE_RSA_WITH_AES_128_GCM_SHA256`
            *
              :attr:`LbHttpSslCondition.USED_SSL_CIPHER_ECDHE_RSA_WITH_AES_256_GCM_SHA384`
            *
              :attr:`LbHttpSslCondition.USED_SSL_CIPHER_ECDHE_RSA_WITH_AES_256_CBC_SHA`
            *
              :attr:`LbHttpSslCondition.USED_SSL_CIPHER_ECDHE_ECDSA_WITH_AES_256_CBC_SHA`
            *
              :attr:`LbHttpSslCondition.USED_SSL_CIPHER_ECDH_ECDSA_WITH_AES_256_CBC_SHA`
            *
              :attr:`LbHttpSslCondition.USED_SSL_CIPHER_ECDH_RSA_WITH_AES_256_CBC_SHA`
            *
              :attr:`LbHttpSslCondition.USED_SSL_CIPHER_RSA_WITH_AES_256_CBC_SHA`
            *
              :attr:`LbHttpSslCondition.USED_SSL_CIPHER_RSA_WITH_AES_128_CBC_SHA`
            *
              :attr:`LbHttpSslCondition.USED_SSL_CIPHER_RSA_WITH_3DES_EDE_CBC_SHA`
            *
              :attr:`LbHttpSslCondition.USED_SSL_CIPHER_ECDHE_RSA_WITH_AES_128_CBC_SHA`
            *
              :attr:`LbHttpSslCondition.USED_SSL_CIPHER_ECDHE_RSA_WITH_AES_128_CBC_SHA256`
            *
              :attr:`LbHttpSslCondition.USED_SSL_CIPHER_ECDHE_RSA_WITH_AES_256_CBC_SHA384`
            *
              :attr:`LbHttpSslCondition.USED_SSL_CIPHER_RSA_WITH_AES_128_CBC_SHA256`
            *
              :attr:`LbHttpSslCondition.USED_SSL_CIPHER_RSA_WITH_AES_128_GCM_SHA256`
            *
              :attr:`LbHttpSslCondition.USED_SSL_CIPHER_RSA_WITH_AES_256_CBC_SHA256`
            *
              :attr:`LbHttpSslCondition.USED_SSL_CIPHER_RSA_WITH_AES_256_GCM_SHA384`
            *
              :attr:`LbHttpSslCondition.USED_SSL_CIPHER_ECDHE_ECDSA_WITH_AES_128_CBC_SHA`
            *
              :attr:`LbHttpSslCondition.USED_SSL_CIPHER_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256`
            *
              :attr:`LbHttpSslCondition.USED_SSL_CIPHER_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256`
            *
              :attr:`LbHttpSslCondition.USED_SSL_CIPHER_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384`
            *
              :attr:`LbHttpSslCondition.USED_SSL_CIPHER_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384`
            *
              :attr:`LbHttpSslCondition.USED_SSL_CIPHER_ECDH_ECDSA_WITH_AES_128_CBC_SHA`
            *
              :attr:`LbHttpSslCondition.USED_SSL_CIPHER_ECDH_ECDSA_WITH_AES_128_CBC_SHA256`
            *
              :attr:`LbHttpSslCondition.USED_SSL_CIPHER_ECDH_ECDSA_WITH_AES_128_GCM_SHA256`
            *
              :attr:`LbHttpSslCondition.USED_SSL_CIPHER_ECDH_ECDSA_WITH_AES_256_CBC_SHA384`
            *
              :attr:`LbHttpSslCondition.USED_SSL_CIPHER_ECDH_ECDSA_WITH_AES_256_GCM_SHA384`
            *
              :attr:`LbHttpSslCondition.USED_SSL_CIPHER_ECDH_RSA_WITH_AES_128_CBC_SHA`
            *
              :attr:`LbHttpSslCondition.USED_SSL_CIPHER_ECDH_RSA_WITH_AES_128_CBC_SHA256`
            *
              :attr:`LbHttpSslCondition.USED_SSL_CIPHER_ECDH_RSA_WITH_AES_128_GCM_SHA256`
            *
              :attr:`LbHttpSslCondition.USED_SSL_CIPHER_ECDH_RSA_WITH_AES_256_CBC_SHA384`
            *
              :attr:`LbHttpSslCondition.USED_SSL_CIPHER_ECDH_RSA_WITH_AES_256_GCM_SHA384`
            
             Cipher used for an established SSL connection
        :type  inverse: :class:`bool` or ``None``
        :param inverse: A flag to indicate whether reverse the match result of this
            condition
        :type  type: :class:`str`
        :param type: Possible values are: 
            
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTMETHODCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTURICONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTURIARGUMENTSCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTVERSIONCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTHEADERCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTCOOKIECONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTBODYCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPRESPONSEHEADERCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBTCPHEADERCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBIPHEADERCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBVARIABLECONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPSSLCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBSSLSNICONDITION`
            
             Type of load balancer rule condition
        """
        self.client_certificate_issuer_dn = client_certificate_issuer_dn
        self.client_certificate_subject_dn = client_certificate_subject_dn
        self.client_supported_ssl_ciphers = client_supported_ssl_ciphers
        self.session_reused = session_reused
        self.used_protocol = used_protocol
        self.used_ssl_cipher = used_ssl_cipher
        self.inverse = inverse
        self._type = type
        VapiStruct.__init__(self)

    @property
    def type(self):
        """
        Return the discriminator value
        """
        return self._type

LbHttpSslCondition._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_http_ssl_condition', {
        'client_certificate_issuer_dn': type.OptionalType(type.ReferenceType(__name__, 'LbClientCertificateIssuerDnCondition')),
        'client_certificate_subject_dn': type.OptionalType(type.ReferenceType(__name__, 'LbClientCertificateSubjectDnCondition')),
        'client_supported_ssl_ciphers': type.OptionalType(type.ListType(type.StringType())),
        'session_reused': type.OptionalType(type.StringType()),
        'used_protocol': type.OptionalType(type.StringType()),
        'used_ssl_cipher': type.OptionalType(type.StringType()),
        'inverse': type.OptionalType(type.BooleanType()),
        'type': type.StringType(),
    },
    LbHttpSslCondition,
    False,
    None))



class LbHttpsMonitor(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    CIPHER_GROUP_LABEL_BALANCED = "BALANCED"
    """


    """
    CIPHER_GROUP_LABEL_HIGH_SECURITY = "HIGH_SECURITY"
    """


    """
    CIPHER_GROUP_LABEL_HIGH_COMPATIBILITY = "HIGH_COMPATIBILITY"
    """


    """
    CIPHER_GROUP_LABEL_CUSTOM = "CUSTOM"
    """


    """
    CIPHERS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 = "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256"
    """


    """
    CIPHERS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 = "TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384"
    """


    """
    CIPHERS_ECDHE_RSA_WITH_AES_256_CBC_SHA = "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA"
    """


    """
    CIPHERS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA = "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA"
    """


    """
    CIPHERS_ECDH_ECDSA_WITH_AES_256_CBC_SHA = "TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA"
    """


    """
    CIPHERS_ECDH_RSA_WITH_AES_256_CBC_SHA = "TLS_ECDH_RSA_WITH_AES_256_CBC_SHA"
    """


    """
    CIPHERS_RSA_WITH_AES_256_CBC_SHA = "TLS_RSA_WITH_AES_256_CBC_SHA"
    """


    """
    CIPHERS_RSA_WITH_AES_128_CBC_SHA = "TLS_RSA_WITH_AES_128_CBC_SHA"
    """


    """
    CIPHERS_RSA_WITH_3DES_EDE_CBC_SHA = "TLS_RSA_WITH_3DES_EDE_CBC_SHA"
    """


    """
    CIPHERS_ECDHE_RSA_WITH_AES_128_CBC_SHA = "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA"
    """


    """
    CIPHERS_ECDHE_RSA_WITH_AES_128_CBC_SHA256 = "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256"
    """


    """
    CIPHERS_ECDHE_RSA_WITH_AES_256_CBC_SHA384 = "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384"
    """


    """
    CIPHERS_RSA_WITH_AES_128_CBC_SHA256 = "TLS_RSA_WITH_AES_128_CBC_SHA256"
    """


    """
    CIPHERS_RSA_WITH_AES_128_GCM_SHA256 = "TLS_RSA_WITH_AES_128_GCM_SHA256"
    """


    """
    CIPHERS_RSA_WITH_AES_256_CBC_SHA256 = "TLS_RSA_WITH_AES_256_CBC_SHA256"
    """


    """
    CIPHERS_RSA_WITH_AES_256_GCM_SHA384 = "TLS_RSA_WITH_AES_256_GCM_SHA384"
    """


    """
    CIPHERS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA = "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA"
    """


    """
    CIPHERS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256 = "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256"
    """


    """
    CIPHERS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 = "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256"
    """


    """
    CIPHERS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384 = "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384"
    """


    """
    CIPHERS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384 = "TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384"
    """


    """
    CIPHERS_ECDH_ECDSA_WITH_AES_128_CBC_SHA = "TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA"
    """


    """
    CIPHERS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256 = "TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256"
    """


    """
    CIPHERS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256 = "TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256"
    """


    """
    CIPHERS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384 = "TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384"
    """


    """
    CIPHERS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384 = "TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384"
    """


    """
    CIPHERS_ECDH_RSA_WITH_AES_128_CBC_SHA = "TLS_ECDH_RSA_WITH_AES_128_CBC_SHA"
    """


    """
    CIPHERS_ECDH_RSA_WITH_AES_128_CBC_SHA256 = "TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256"
    """


    """
    CIPHERS_ECDH_RSA_WITH_AES_128_GCM_SHA256 = "TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256"
    """


    """
    CIPHERS_ECDH_RSA_WITH_AES_256_CBC_SHA384 = "TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384"
    """


    """
    CIPHERS_ECDH_RSA_WITH_AES_256_GCM_SHA384 = "TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384"
    """


    """
    PROTOCOLS_SSL_V2 = "SSL_V2"
    """


    """
    PROTOCOLS_SSL_V3 = "SSL_V3"
    """


    """
    PROTOCOLS_TLS_V1 = "TLS_V1"
    """


    """
    PROTOCOLS_TLS_V1_1 = "TLS_V1_1"
    """


    """
    PROTOCOLS_TLS_V1_2 = "TLS_V1_2"
    """


    """
    REQUEST_METHOD_GET = "GET"
    """


    """
    REQUEST_METHOD_OPTIONS = "OPTIONS"
    """


    """
    REQUEST_METHOD_POST = "POST"
    """


    """
    REQUEST_METHOD_HEAD = "HEAD"
    """


    """
    REQUEST_METHOD_PUT = "PUT"
    """


    """
    REQUEST_VERSION_1_0 = "HTTP_VERSION_1_0"
    """


    """
    REQUEST_VERSION_1_1 = "HTTP_VERSION_1_1"
    """


    """
    REQUEST_VERSION_2_0 = "HTTP_VERSION_2_0"
    """


    """
    SERVER_AUTH_REQUIRED = "REQUIRED"
    """


    """
    SERVER_AUTH_IGNORE = "IGNORE"
    """


    """



    _canonical_to_pep_names = {
                            'certificate_chain_depth': 'certificate_chain_depth',
                            'cipher_group_label': 'cipher_group_label',
                            'ciphers': 'ciphers',
                            'client_certificate_id': 'client_certificate_id',
                            'is_fips': 'is_fips',
                            'is_secure': 'is_secure',
                            'protocols': 'protocols',
                            'request_body': 'request_body',
                            'request_headers': 'request_headers',
                            'request_method': 'request_method',
                            'request_url': 'request_url',
                            'request_version': 'request_version',
                            'response_body': 'response_body',
                            'response_status_codes': 'response_status_codes',
                            'server_auth': 'server_auth',
                            'server_auth_ca_ids': 'server_auth_ca_ids',
                            'server_auth_crl_ids': 'server_auth_crl_ids',
                            'fall_count': 'fall_count',
                            'interval': 'interval',
                            'monitor_port': 'monitor_port',
                            'rise_count': 'rise_count',
                            'timeout': 'timeout',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            }

    def __init__(self,
                 certificate_chain_depth=None,
                 cipher_group_label=None,
                 ciphers=None,
                 client_certificate_id=None,
                 is_fips=None,
                 is_secure=None,
                 protocols=None,
                 request_body=None,
                 request_headers=None,
                 request_method=None,
                 request_url=None,
                 request_version=None,
                 response_body=None,
                 response_status_codes=None,
                 server_auth=None,
                 server_auth_ca_ids=None,
                 server_auth_crl_ids=None,
                 fall_count=None,
                 interval=None,
                 monitor_port=None,
                 rise_count=None,
                 timeout=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                ):
        """
        :type  certificate_chain_depth: :class:`long` or ``None``
        :param certificate_chain_depth: authentication depth is used to set the verification depth in the
            server certificates chain. format: int64
        :type  cipher_group_label: :class:`str` or ``None``
        :param cipher_group_label: Possible values are: 
            
            * :attr:`LbHttpsMonitor.CIPHER_GROUP_LABEL_BALANCED`
            * :attr:`LbHttpsMonitor.CIPHER_GROUP_LABEL_HIGH_SECURITY`
            * :attr:`LbHttpsMonitor.CIPHER_GROUP_LABEL_HIGH_COMPATIBILITY`
            * :attr:`LbHttpsMonitor.CIPHER_GROUP_LABEL_CUSTOM`
            
             It is a label of cipher group which is mostly consumed by GUI.
        :type  ciphers: :class:`list` of :class:`str` or ``None``
        :param ciphers: Possible values are: 
            
            * :attr:`LbHttpsMonitor.CIPHERS_ECDHE_RSA_WITH_AES_128_GCM_SHA256`
            * :attr:`LbHttpsMonitor.CIPHERS_ECDHE_RSA_WITH_AES_256_GCM_SHA384`
            * :attr:`LbHttpsMonitor.CIPHERS_ECDHE_RSA_WITH_AES_256_CBC_SHA`
            * :attr:`LbHttpsMonitor.CIPHERS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA`
            * :attr:`LbHttpsMonitor.CIPHERS_ECDH_ECDSA_WITH_AES_256_CBC_SHA`
            * :attr:`LbHttpsMonitor.CIPHERS_ECDH_RSA_WITH_AES_256_CBC_SHA`
            * :attr:`LbHttpsMonitor.CIPHERS_RSA_WITH_AES_256_CBC_SHA`
            * :attr:`LbHttpsMonitor.CIPHERS_RSA_WITH_AES_128_CBC_SHA`
            * :attr:`LbHttpsMonitor.CIPHERS_RSA_WITH_3DES_EDE_CBC_SHA`
            * :attr:`LbHttpsMonitor.CIPHERS_ECDHE_RSA_WITH_AES_128_CBC_SHA`
            * :attr:`LbHttpsMonitor.CIPHERS_ECDHE_RSA_WITH_AES_128_CBC_SHA256`
            * :attr:`LbHttpsMonitor.CIPHERS_ECDHE_RSA_WITH_AES_256_CBC_SHA384`
            * :attr:`LbHttpsMonitor.CIPHERS_RSA_WITH_AES_128_CBC_SHA256`
            * :attr:`LbHttpsMonitor.CIPHERS_RSA_WITH_AES_128_GCM_SHA256`
            * :attr:`LbHttpsMonitor.CIPHERS_RSA_WITH_AES_256_CBC_SHA256`
            * :attr:`LbHttpsMonitor.CIPHERS_RSA_WITH_AES_256_GCM_SHA384`
            * :attr:`LbHttpsMonitor.CIPHERS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA`
            *
              :attr:`LbHttpsMonitor.CIPHERS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256`
            *
              :attr:`LbHttpsMonitor.CIPHERS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256`
            *
              :attr:`LbHttpsMonitor.CIPHERS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384`
            *
              :attr:`LbHttpsMonitor.CIPHERS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384`
            * :attr:`LbHttpsMonitor.CIPHERS_ECDH_ECDSA_WITH_AES_128_CBC_SHA`
            * :attr:`LbHttpsMonitor.CIPHERS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256`
            * :attr:`LbHttpsMonitor.CIPHERS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256`
            * :attr:`LbHttpsMonitor.CIPHERS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384`
            * :attr:`LbHttpsMonitor.CIPHERS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384`
            * :attr:`LbHttpsMonitor.CIPHERS_ECDH_RSA_WITH_AES_128_CBC_SHA`
            * :attr:`LbHttpsMonitor.CIPHERS_ECDH_RSA_WITH_AES_128_CBC_SHA256`
            * :attr:`LbHttpsMonitor.CIPHERS_ECDH_RSA_WITH_AES_128_GCM_SHA256`
            * :attr:`LbHttpsMonitor.CIPHERS_ECDH_RSA_WITH_AES_256_CBC_SHA384`
            * :attr:`LbHttpsMonitor.CIPHERS_ECDH_RSA_WITH_AES_256_GCM_SHA384`
            
             supported SSL cipher list to servers
        :type  client_certificate_id: :class:`str` or ``None``
        :param client_certificate_id: client certificate can be specified to support client
            authentication.
        :type  is_fips: :class:`bool` or ``None``
        :param is_fips: This flag is set to true when all the ciphers and protocols are
            FIPS compliant. It is set to false when one of the ciphers or
            protocols are not FIPS compliant..
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  is_secure: :class:`bool` or ``None``
        :param is_secure: This flag is set to true when all the ciphers and protocols are
            secure. It is set to false when one of the ciphers or protocols is
            insecure.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protocols: :class:`list` of :class:`str` or ``None``
        :param protocols: Possible values are: 
            
            * :attr:`LbHttpsMonitor.PROTOCOLS_SSL_V2`
            * :attr:`LbHttpsMonitor.PROTOCOLS_SSL_V3`
            * :attr:`LbHttpsMonitor.PROTOCOLS_TLS_V1`
            * :attr:`LbHttpsMonitor.PROTOCOLS_TLS_V1_1`
            * :attr:`LbHttpsMonitor.PROTOCOLS_TLS_V1_2`
            
            SSL versions TLS1.1 and TLS1.2 are supported and enabled by
            default. SSLv2, SSLv3, and TLS1.0 are supported, but disabled by
            default.
        :type  request_body: :class:`str` or ``None``
        :param request_body: String to send as part of HTTP health check request body. Valid
            only for certain HTTP methods like POST.
        :type  request_headers: :class:`list` of :class:`LbHttpRequestHeader` or ``None``
        :param request_headers: Array of HTTP request headers
        :type  request_method: :class:`str` or ``None``
        :param request_method: Possible values are: 
            
            * :attr:`LbHttpsMonitor.REQUEST_METHOD_GET`
            * :attr:`LbHttpsMonitor.REQUEST_METHOD_OPTIONS`
            * :attr:`LbHttpsMonitor.REQUEST_METHOD_POST`
            * :attr:`LbHttpsMonitor.REQUEST_METHOD_HEAD`
            * :attr:`LbHttpsMonitor.REQUEST_METHOD_PUT`
            
             the health check method for HTTP monitor type
        :type  request_url: :class:`str` or ``None``
        :param request_url: URL used for HTTP monitor
        :type  request_version: :class:`str` or ``None``
        :param request_version: Possible values are: 
            
            * :attr:`LbHttpsMonitor.REQUEST_VERSION__1_0`
            * :attr:`LbHttpsMonitor.REQUEST_VERSION__1_1`
            * :attr:`LbHttpsMonitor.REQUEST_VERSION__2_0`
            
             HTTP request version
        :type  response_body: :class:`str` or ``None``
        :param response_body: If HTTP response body match string (regular expressions not
            supported) is specified (using LbHttpMonitor.response_body) then
            the healthcheck HTTP response body is matched against the specified
            string and server is considered healthy only if there is a match.
            If the response body string is not specified, HTTP healthcheck is
            considered successful if the HTTP response status code is 2xx, but
            it can be configured to accept other status codes as successful.
        :type  response_status_codes: :class:`list` of :class:`long` or ``None``
        :param response_status_codes: The HTTP response status code should be a valid HTTP status code.
            format: int32
        :type  server_auth: :class:`str` or ``None``
        :param server_auth: Possible values are: 
            
            * :attr:`LbHttpsMonitor.SERVER_AUTH_REQUIRED`
            * :attr:`LbHttpsMonitor.SERVER_AUTH_IGNORE`
            
             server authentication mode
        :type  server_auth_ca_ids: :class:`list` of :class:`str` or ``None``
        :param server_auth_ca_ids: If server auth type is REQUIRED, server certificate must be signed
            by one of the trusted Certificate Authorities (CAs), also referred
            to as root CAs, whose self signed certificates are specified.
        :type  server_auth_crl_ids: :class:`list` of :class:`str` or ``None``
        :param server_auth_crl_ids: A Certificate Revocation List (CRL) can be specified in the
            server-side SSL profile binding to disallow compromised server
            certificates.
        :type  fall_count: :class:`long` or ``None``
        :param fall_count: num of consecutive checks must fail before marking it down format:
            int64
        :type  interval: :class:`long` or ``None``
        :param interval: the frequency at which the system issues the monitor check (in
            second) format: int64
        :type  monitor_port: :class:`str` or ``None``
        :param monitor_port: If the monitor port is specified, it would override pool member
            port setting for healthcheck. A port range is not supported. For
            ICMP monitor, monitor_port is not required. format: port-or-range
        :type  rise_count: :class:`long` or ``None``
        :param rise_count: num of consecutive checks must pass before marking it up format:
            int64
        :type  timeout: :class:`long` or ``None``
        :param timeout: the number of seconds the target has in which to respond to the
            monitor request format: int64
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`LbMonitor.RESOURCE_TYPE_LBHTTPMONITOR`
            * :attr:`LbMonitor.RESOURCE_TYPE_LBHTTPSMONITOR`
            * :attr:`LbMonitor.RESOURCE_TYPE_LBICMPMONITOR`
            * :attr:`LbMonitor.RESOURCE_TYPE_LBTCPMONITOR`
            * :attr:`LbMonitor.RESOURCE_TYPE_LBUDPMONITOR`
            * :attr:`LbMonitor.RESOURCE_TYPE_LBPASSIVEMONITOR`
            
            Load balancers monitor the health of backend servers to ensure
            traffic is not black holed. There are two types of healthchecks:
            active and passive. Passive healthchecks depend on failures in
            actual client traffic (e.g. RST from server in response to a client
            connection) to detect that the server or the application is down.
            In case of active healthchecks, load balancer itself initiates new
            connections (or sends ICMP ping) to the servers periodically to
            check their health, completely independent of any data traffic.
            Currently, active health monitors are supported for HTTP, HTTPS,
            TCP, UDP and ICMP protocols.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        """
        self.certificate_chain_depth = certificate_chain_depth
        self.cipher_group_label = cipher_group_label
        self.ciphers = ciphers
        self.client_certificate_id = client_certificate_id
        self.is_fips = is_fips
        self.is_secure = is_secure
        self.protocols = protocols
        self.request_body = request_body
        self.request_headers = request_headers
        self.request_method = request_method
        self.request_url = request_url
        self.request_version = request_version
        self.response_body = response_body
        self.response_status_codes = response_status_codes
        self.server_auth = server_auth
        self.server_auth_ca_ids = server_auth_ca_ids
        self.server_auth_crl_ids = server_auth_crl_ids
        self.fall_count = fall_count
        self.interval = interval
        self.monitor_port = monitor_port
        self.rise_count = rise_count
        self.timeout = timeout
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

LbHttpsMonitor._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_https_monitor', {
        'certificate_chain_depth': type.OptionalType(type.IntegerType()),
        'cipher_group_label': type.OptionalType(type.StringType()),
        'ciphers': type.OptionalType(type.ListType(type.StringType())),
        'client_certificate_id': type.OptionalType(type.StringType()),
        'is_fips': type.OptionalType(type.BooleanType()),
        'is_secure': type.OptionalType(type.BooleanType()),
        'protocols': type.OptionalType(type.ListType(type.StringType())),
        'request_body': type.OptionalType(type.StringType()),
        'request_headers': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'LbHttpRequestHeader'))),
        'request_method': type.OptionalType(type.StringType()),
        'request_url': type.OptionalType(type.StringType()),
        'request_version': type.OptionalType(type.StringType()),
        'response_body': type.OptionalType(type.StringType()),
        'response_status_codes': type.OptionalType(type.ListType(type.IntegerType())),
        'server_auth': type.OptionalType(type.StringType()),
        'server_auth_ca_ids': type.OptionalType(type.ListType(type.StringType())),
        'server_auth_crl_ids': type.OptionalType(type.ListType(type.StringType())),
        'fall_count': type.OptionalType(type.IntegerType()),
        'interval': type.OptionalType(type.IntegerType()),
        'monitor_port': type.OptionalType(type.StringType()),
        'rise_count': type.OptionalType(type.IntegerType()),
        'timeout': type.OptionalType(type.IntegerType()),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
    },
    LbHttpsMonitor,
    False,
    None))



class LbIcmpMonitor(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'data_length': 'data_length',
                            'fall_count': 'fall_count',
                            'interval': 'interval',
                            'monitor_port': 'monitor_port',
                            'rise_count': 'rise_count',
                            'timeout': 'timeout',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            }

    def __init__(self,
                 data_length=None,
                 fall_count=None,
                 interval=None,
                 monitor_port=None,
                 rise_count=None,
                 timeout=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                ):
        """
        :type  data_length: :class:`long` or ``None``
        :param data_length: The data size(in byte) of the ICMP healthcheck packet format: int64
        :type  fall_count: :class:`long` or ``None``
        :param fall_count: num of consecutive checks must fail before marking it down format:
            int64
        :type  interval: :class:`long` or ``None``
        :param interval: the frequency at which the system issues the monitor check (in
            second) format: int64
        :type  monitor_port: :class:`str` or ``None``
        :param monitor_port: If the monitor port is specified, it would override pool member
            port setting for healthcheck. A port range is not supported. For
            ICMP monitor, monitor_port is not required. format: port-or-range
        :type  rise_count: :class:`long` or ``None``
        :param rise_count: num of consecutive checks must pass before marking it up format:
            int64
        :type  timeout: :class:`long` or ``None``
        :param timeout: the number of seconds the target has in which to respond to the
            monitor request format: int64
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`LbMonitor.RESOURCE_TYPE_LBHTTPMONITOR`
            * :attr:`LbMonitor.RESOURCE_TYPE_LBHTTPSMONITOR`
            * :attr:`LbMonitor.RESOURCE_TYPE_LBICMPMONITOR`
            * :attr:`LbMonitor.RESOURCE_TYPE_LBTCPMONITOR`
            * :attr:`LbMonitor.RESOURCE_TYPE_LBUDPMONITOR`
            * :attr:`LbMonitor.RESOURCE_TYPE_LBPASSIVEMONITOR`
            
            Load balancers monitor the health of backend servers to ensure
            traffic is not black holed. There are two types of healthchecks:
            active and passive. Passive healthchecks depend on failures in
            actual client traffic (e.g. RST from server in response to a client
            connection) to detect that the server or the application is down.
            In case of active healthchecks, load balancer itself initiates new
            connections (or sends ICMP ping) to the servers periodically to
            check their health, completely independent of any data traffic.
            Currently, active health monitors are supported for HTTP, HTTPS,
            TCP, UDP and ICMP protocols.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        """
        self.data_length = data_length
        self.fall_count = fall_count
        self.interval = interval
        self.monitor_port = monitor_port
        self.rise_count = rise_count
        self.timeout = timeout
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

LbIcmpMonitor._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_icmp_monitor', {
        'data_length': type.OptionalType(type.IntegerType()),
        'fall_count': type.OptionalType(type.IntegerType()),
        'interval': type.OptionalType(type.IntegerType()),
        'monitor_port': type.OptionalType(type.StringType()),
        'rise_count': type.OptionalType(type.IntegerType()),
        'timeout': type.OptionalType(type.IntegerType()),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
    },
    LbIcmpMonitor,
    False,
    None))



class LbIpHeaderCondition(VapiStruct):
    """
    This condition is used to match IP header fields of HTTP messages. Either
    source_address or group_id should be specified.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LbIpHeaderCondition"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'group_id': 'group_id',
                            'source_address': 'source_address',
                            'inverse': 'inverse',
                            'type': 'type',
                            }

    def __init__(self,
                 group_id=None,
                 source_address=None,
                 inverse=None,
                 type='LbIpHeaderCondition',
                ):
        """
        :type  group_id: :class:`str` or ``None``
        :param group_id: Source IP address of HTTP message should match IP addresses which
            are configured in Group in order to perform actions.
        :type  source_address: :class:`str` or ``None``
        :param source_address: Source IP address of HTTP message. IP Address can be expressed as a
            single IP address like 10.1.1.1, or a range of IP addresses like
            10.1.1.101-10.1.1.160. Both IPv4 and IPv6 addresses are supported.
            format: address-or-block-or-range
        :type  inverse: :class:`bool` or ``None``
        :param inverse: A flag to indicate whether reverse the match result of this
            condition
        :type  type: :class:`str`
        :param type: Possible values are: 
            
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTMETHODCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTURICONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTURIARGUMENTSCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTVERSIONCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTHEADERCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTCOOKIECONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTBODYCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPRESPONSEHEADERCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBTCPHEADERCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBIPHEADERCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBVARIABLECONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPSSLCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBSSLSNICONDITION`
            
             Type of load balancer rule condition
        """
        self.group_id = group_id
        self.source_address = source_address
        self.inverse = inverse
        self._type = type
        VapiStruct.__init__(self)

    @property
    def type(self):
        """
        Return the discriminator value
        """
        return self._type

LbIpHeaderCondition._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_ip_header_condition', {
        'group_id': type.OptionalType(type.StringType()),
        'source_address': type.OptionalType(type.StringType()),
        'inverse': type.OptionalType(type.BooleanType()),
        'type': type.StringType(),
    },
    LbIpHeaderCondition,
    False,
    None))



class LbJwtAuthAction(VapiStruct):
    """
    This action is used to control access to backend server resources using
    JSON Web Token(JWT) authentication. The JWT authentication is done before
    any HTTP manipulation if the HTTP request matches the given condition in
    LbRule. Any verification failed, the HTTP process will be terminated, and
    HTTP response with 401 status code and WWW-Authentication header will be
    returned to client.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LbJwtAuthAction"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'key': 'key',
                            'pass_jwt_to_pool': 'pass_jwt_to_pool',
                            'realm': 'realm',
                            'tokens': 'tokens',
                            'type': 'type',
                            }

    def __init__(self,
                 key=None,
                 pass_jwt_to_pool=None,
                 realm=None,
                 tokens=None,
                 type='LbJwtAuthAction',
                ):
        """
        :type  key: :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param key: LbJwtKey used for verifying the signature of JWT token
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`LbJwtKey`. When methods return a value of this class as a
            return value, the attribute will contain all the attributes defined
            in :class:`LbJwtKey`.
        :type  pass_jwt_to_pool: :class:`bool` or ``None``
        :param pass_jwt_to_pool: Specify whether to pass the JWT to backend server or remove it. By
            default, it is false which means will not pass the JWT to backend
            servers.
        :type  realm: :class:`str` or ``None``
        :param realm: A description of the protected area. If no realm is specified,
            clients often display a formatted hostname instead. The configured
            realm is returned when client request is rejected with 401 http
            status. In the response, it will be \"WWW-Authentication: Bearer
            realm=<realm>\".
        :type  tokens: :class:`list` of :class:`str` or ``None``
        :param tokens: JWT is an open standard that defines a compact and self-contained
            way for securely transmitting information between parties as a JSON
            object. Load balancer will search for every specified tokens one by
            one for the jwt message until found. This parameter is optional. In
            case not found or this field is not configured, load balancer
            searches the Bearer header by default in the http request
            \"Authorization: Bearer <token>\".
        :type  type: :class:`str`
        :param type: Possible values are: 
            
            * :attr:`LbRuleAction.TYPE_LBHTTPREQUESTURIREWRITEACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPREQUESTHEADERREWRITEACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPREJECTACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPREDIRECTACTION`
            * :attr:`LbRuleAction.TYPE_LBSELECTPOOLACTION`
            * :attr:`LbRuleAction.TYPE_LBSELECTSERVERACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPRESPONSEHEADERREWRITEACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPREQUESTHEADERDELETEACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPRESPONSEHEADERDELETEACTION`
            * :attr:`LbRuleAction.TYPE_LBVARIABLEASSIGNMENTACTION`
            * :attr:`LbRuleAction.TYPE_LBVARIABLEPERSISTENCEONACTION`
            * :attr:`LbRuleAction.TYPE_LBVARIABLEPERSISTENCELEARNACTION`
            * :attr:`LbRuleAction.TYPE_LBJWTAUTHACTION`
            * :attr:`LbRuleAction.TYPE_LBSSLMODESELECTIONACTION`
            * :attr:`LbRuleAction.TYPE_LBCONNECTIONDROPACTION`
            
             The property identifies the load balancer rule action type.
        """
        self.key = key
        self.pass_jwt_to_pool = pass_jwt_to_pool
        self.realm = realm
        self.tokens = tokens
        self._type = type
        VapiStruct.__init__(self)

    @property
    def type(self):
        """
        Return the discriminator value
        """
        return self._type

LbJwtAuthAction._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_jwt_auth_action', {
        'key': type.OptionalType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'LbJwtKey')])),
        'pass_jwt_to_pool': type.OptionalType(type.BooleanType()),
        'realm': type.OptionalType(type.StringType()),
        'tokens': type.OptionalType(type.ListType(type.StringType())),
        'type': type.StringType(),
    },
    LbJwtAuthAction,
    False,
    None))



class LbJwtCertificateKey(VapiStruct):
    """
    The key is used to specify certificate which is used to verify the
    signature of JWT tokens.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LbJwtCertificateKey"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'certificate_id': 'certificate_id',
                            'type': 'type',
                            }

    def __init__(self,
                 certificate_id=None,
                 type='LbJwtCertificateKey',
                ):
        """
        :type  certificate_id: :class:`str` or ``None``
        :param certificate_id: Certificate identifier
        :type  type: :class:`str`
        :param type: Possible values are: 
            
            * :attr:`LbJwtKey.TYPE_LBJWTCERTIFICATEKEY`
            * :attr:`LbJwtKey.TYPE_LBJWTSYMMETRICKEY`
            * :attr:`LbJwtKey.TYPE_LBJWTPUBLICKEY`
            
             The property is used to identify JWT key type.
        """
        self.certificate_id = certificate_id
        self._type = type
        VapiStruct.__init__(self)

    @property
    def type(self):
        """
        Return the discriminator value
        """
        return self._type

LbJwtCertificateKey._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_jwt_certificate_key', {
        'certificate_id': type.OptionalType(type.StringType()),
        'type': type.StringType(),
    },
    LbJwtCertificateKey,
    False,
    None))



class LbJwtKey(VapiStruct):
    """
    LbJwtKey specifies the symmetric key or asymmetric public key used to
    decrypt the data in JWT.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LbJwtKey"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    TYPE_LBJWTCERTIFICATEKEY = "LbJwtCertificateKey"
    """


    """
    TYPE_LBJWTSYMMETRICKEY = "LbJwtSymmetricKey"
    """


    """
    TYPE_LBJWTPUBLICKEY = "LbJwtPublicKey"
    """


    """



    _canonical_to_pep_names = {
                            'type': 'type',
                            }

    def __init__(self,
                 type='LbJwtKey',
                ):
        """
        :type  type: :class:`str`
        :param type: Possible values are: 
            
            * :attr:`LbJwtKey.TYPE_LBJWTCERTIFICATEKEY`
            * :attr:`LbJwtKey.TYPE_LBJWTSYMMETRICKEY`
            * :attr:`LbJwtKey.TYPE_LBJWTPUBLICKEY`
            
             The property is used to identify JWT key type.
        """
        self._type = type
        VapiStruct.__init__(self)

    @property
    def type(self):
        """
        Return the discriminator value
        """
        return self._type

LbJwtKey._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_jwt_key', {
        'type': type.StringType(),
    },
    LbJwtKey,
    False,
    None))



class LbJwtPublicKey(VapiStruct):
    """
    The key is used to specify the public key content which is used to verify
    the signature of JWT tokens.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LbJwtPublicKey"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'public_key_content': 'public_key_content',
                            'type': 'type',
                            }

    def __init__(self,
                 public_key_content=None,
                 type='LbJwtPublicKey',
                ):
        """
        :type  public_key_content: :class:`str` or ``None``
        :param public_key_content: Content of public key
        :type  type: :class:`str`
        :param type: Possible values are: 
            
            * :attr:`LbJwtKey.TYPE_LBJWTCERTIFICATEKEY`
            * :attr:`LbJwtKey.TYPE_LBJWTSYMMETRICKEY`
            * :attr:`LbJwtKey.TYPE_LBJWTPUBLICKEY`
            
             The property is used to identify JWT key type.
        """
        self.public_key_content = public_key_content
        self._type = type
        VapiStruct.__init__(self)

    @property
    def type(self):
        """
        Return the discriminator value
        """
        return self._type

LbJwtPublicKey._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_jwt_public_key', {
        'public_key_content': type.OptionalType(type.StringType()),
        'type': type.StringType(),
    },
    LbJwtPublicKey,
    False,
    None))



class LbJwtSymmetricKey(VapiStruct):
    """
    The key is used to specify the symmetric key which is used to verify the
    signature of JWT tokens.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LbJwtSymmetricKey"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'type': 'type',
                            }

    def __init__(self,
                 type='LbJwtSymmetricKey',
                ):
        """
        :type  type: :class:`str`
        :param type: Possible values are: 
            
            * :attr:`LbJwtKey.TYPE_LBJWTCERTIFICATEKEY`
            * :attr:`LbJwtKey.TYPE_LBJWTSYMMETRICKEY`
            * :attr:`LbJwtKey.TYPE_LBJWTPUBLICKEY`
            
             The property is used to identify JWT key type.
        """
        self._type = type
        VapiStruct.__init__(self)

    @property
    def type(self):
        """
        Return the discriminator value
        """
        return self._type

LbJwtSymmetricKey._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_jwt_symmetric_key', {
        'type': type.StringType(),
    },
    LbJwtSymmetricKey,
    False,
    None))



class LbMonitor(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LbMonitor"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    RESOURCE_TYPE_LBHTTPMONITOR = "LbHttpMonitor"
    """


    """
    RESOURCE_TYPE_LBHTTPSMONITOR = "LbHttpsMonitor"
    """


    """
    RESOURCE_TYPE_LBICMPMONITOR = "LbIcmpMonitor"
    """


    """
    RESOURCE_TYPE_LBTCPMONITOR = "LbTcpMonitor"
    """


    """
    RESOURCE_TYPE_LBUDPMONITOR = "LbUdpMonitor"
    """


    """
    RESOURCE_TYPE_LBPASSIVEMONITOR = "LbPassiveMonitor"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='LbMonitor',
                 tags=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`LbMonitor.RESOURCE_TYPE_LBHTTPMONITOR`
            * :attr:`LbMonitor.RESOURCE_TYPE_LBHTTPSMONITOR`
            * :attr:`LbMonitor.RESOURCE_TYPE_LBICMPMONITOR`
            * :attr:`LbMonitor.RESOURCE_TYPE_LBTCPMONITOR`
            * :attr:`LbMonitor.RESOURCE_TYPE_LBUDPMONITOR`
            * :attr:`LbMonitor.RESOURCE_TYPE_LBPASSIVEMONITOR`
            
            Load balancers monitor the health of backend servers to ensure
            traffic is not black holed. There are two types of healthchecks:
            active and passive. Passive healthchecks depend on failures in
            actual client traffic (e.g. RST from server in response to a client
            connection) to detect that the server or the application is down.
            In case of active healthchecks, load balancer itself initiates new
            connections (or sends ICMP ping) to the servers periodically to
            check their health, completely independent of any data traffic.
            Currently, active health monitors are supported for HTTP, HTTPS,
            TCP, UDP and ICMP protocols.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

LbMonitor._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_monitor', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
    },
    LbMonitor,
    False,
    None))



class LbMonitorListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param results: paginated list of load balancer monitors
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`LbMonitor`. When methods return a value of this class as a
            return value, the attribute will contain all the attributes defined
            in :class:`LbMonitor`.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


LbMonitorListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_monitor_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'LbMonitor')]))),
    },
    LbMonitorListResult,
    False,
    None))



class LbNodeCountPerSeverity(VapiStruct):
    """
    The node count for specific load balancer usage severity.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    SEVERITY_GREEN = "GREEN"
    """


    """
    SEVERITY_ORANGE = "ORANGE"
    """


    """
    SEVERITY_RED = "RED"
    """


    """



    _canonical_to_pep_names = {
                            'node_count': 'node_count',
                            'severity': 'severity',
                            }

    def __init__(self,
                 node_count=None,
                 severity=None,
                ):
        """
        :type  node_count: :class:`long` or ``None``
        :param node_count: Node count for specific serverity. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  severity: :class:`str` or ``None``
        :param severity: Possible values are: 
            
            * :attr:`LbNodeCountPerSeverity.SEVERITY_GREEN`
            * :attr:`LbNodeCountPerSeverity.SEVERITY_ORANGE`
            * :attr:`LbNodeCountPerSeverity.SEVERITY_RED`
            
            The severity calculation is based on credit usage percentage of
            load balancer for one node.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.node_count = node_count
        self.severity = severity
        VapiStruct.__init__(self)


LbNodeCountPerSeverity._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_node_count_per_severity', {
        'node_count': type.OptionalType(type.IntegerType()),
        'severity': type.OptionalType(type.StringType()),
    },
    LbNodeCountPerSeverity,
    False,
    None))



class LbNodeUsage(VapiStruct):
    """
    Node usage for load balancer contains basic information and LB entity
    usages and capacity for the given node.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LbNodeUsage"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    TYPE_LBEDGENODEUSAGE = "LbEdgeNodeUsage"
    """


    """



    _canonical_to_pep_names = {
                            'node_id': 'node_id',
                            'type': 'type',
                            }

    def __init__(self,
                 node_id=None,
                 type='LbNodeUsage',
                ):
        """
        :type  node_id: :class:`str` or ``None``
        :param node_id: The property identifies the node UUID for load balancer node usage.
        :type  type: :class:`str`
        :param type: Possible values are: 
            
            * :attr:`LbNodeUsage.TYPE_LBEDGENODEUSAGE`
            
             The property identifies the load balancer node usage type.
        """
        self.node_id = node_id
        self._type = type
        VapiStruct.__init__(self)

    @property
    def type(self):
        """
        Return the discriminator value
        """
        return self._type

LbNodeUsage._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_node_usage', {
        'node_id': type.OptionalType(type.StringType()),
        'type': type.StringType(),
    },
    LbNodeUsage,
    False,
    None))



class LbNodeUsageSummary(VapiStruct):
    """
    The load balancer node usage summary for all nodes. Only EdgeNode is
    supported. The summary calculation is based on all edge nodes configured in
    edge clusters.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    SEVERITY_GREEN = "GREEN"
    """


    """
    SEVERITY_ORANGE = "ORANGE"
    """


    """
    SEVERITY_RED = "RED"
    """


    """



    _canonical_to_pep_names = {
                            'current_credit_number': 'current_credit_number',
                            'current_pool_members': 'current_pool_members',
                            'node_counts': 'node_counts',
                            'node_usages': 'node_usages',
                            'remaining_credit_number': 'remaining_credit_number',
                            'remaining_pool_members': 'remaining_pool_members',
                            'severity': 'severity',
                            'usage_percentage': 'usage_percentage',
                            }

    def __init__(self,
                 current_credit_number=None,
                 current_pool_members=None,
                 node_counts=None,
                 node_usages=None,
                 remaining_credit_number=None,
                 remaining_pool_members=None,
                 severity=None,
                 usage_percentage=None,
                ):
        """
        :type  current_credit_number: :class:`long` or ``None``
        :param current_credit_number: The current credit number reflects the overall credit usage for all
            nodes. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  current_pool_members: :class:`long` or ``None``
        :param current_pool_members: The overall number of pool members configured on all nodes. format:
            int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  node_counts: :class:`list` of :class:`LbNodeCountPerSeverity` or ``None``
        :param node_counts: The property identifies array of node count for each severity (RED,
            ORANGE and GREEN).
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  node_usages: :class:`list` of :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param node_usages: The property contains lb node usages for each node.
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`LbNodeUsage`. When methods return a value of this class as
            a return value, the attribute will contain all the attributes
            defined in :class:`LbNodeUsage`.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  remaining_credit_number: :class:`long` or ``None``
        :param remaining_credit_number: The remaining credit number is the overall remaining credits that
            can be used for load balancer service configuration for all nodes.
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  remaining_pool_members: :class:`long` or ``None``
        :param remaining_pool_members: The overall remaining number of pool members which could be
            configured on all nodes. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  severity: :class:`str` or ``None``
        :param severity: Possible values are: 
            
            * :attr:`LbNodeUsageSummary.SEVERITY_GREEN`
            * :attr:`LbNodeUsageSummary.SEVERITY_ORANGE`
            * :attr:`LbNodeUsageSummary.SEVERITY_RED`
            
            The severity calculation is based on current credit usage
            percentage of load balancer for all nodes.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  usage_percentage: :class:`float` or ``None``
        :param usage_percentage: The overall usage percentage of all nodes for load balancer. The
            value is the larger value between overall pool member usage
            percentage and overall load balancer credit usage percentage.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.current_credit_number = current_credit_number
        self.current_pool_members = current_pool_members
        self.node_counts = node_counts
        self.node_usages = node_usages
        self.remaining_credit_number = remaining_credit_number
        self.remaining_pool_members = remaining_pool_members
        self.severity = severity
        self.usage_percentage = usage_percentage
        VapiStruct.__init__(self)


LbNodeUsageSummary._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_node_usage_summary', {
        'current_credit_number': type.OptionalType(type.IntegerType()),
        'current_pool_members': type.OptionalType(type.IntegerType()),
        'node_counts': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'LbNodeCountPerSeverity'))),
        'node_usages': type.OptionalType(type.ListType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'LbNodeUsage')]))),
        'remaining_credit_number': type.OptionalType(type.IntegerType()),
        'remaining_pool_members': type.OptionalType(type.IntegerType()),
        'severity': type.OptionalType(type.StringType()),
        'usage_percentage': type.OptionalType(type.DoubleType()),
    },
    LbNodeUsageSummary,
    False,
    None))



class LbPassiveMonitor(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LbPassiveMonitor"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'max_fails': 'max_fails',
                            'timeout': 'timeout',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            }

    def __init__(self,
                 max_fails=None,
                 timeout=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='LbPassiveMonitor',
                 tags=None,
                ):
        """
        :type  max_fails: :class:`long` or ``None``
        :param max_fails: When the consecutive failures reach this value, then the member is
            considered temporarily unavailable for a configurable period
            format: int64
        :type  timeout: :class:`long` or ``None``
        :param timeout: After this timeout period, the member is tried again for a new
            connection to see if it is available. format: int64
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`LbMonitor.RESOURCE_TYPE_LBHTTPMONITOR`
            * :attr:`LbMonitor.RESOURCE_TYPE_LBHTTPSMONITOR`
            * :attr:`LbMonitor.RESOURCE_TYPE_LBICMPMONITOR`
            * :attr:`LbMonitor.RESOURCE_TYPE_LBTCPMONITOR`
            * :attr:`LbMonitor.RESOURCE_TYPE_LBUDPMONITOR`
            * :attr:`LbMonitor.RESOURCE_TYPE_LBPASSIVEMONITOR`
            
            Load balancers monitor the health of backend servers to ensure
            traffic is not black holed. There are two types of healthchecks:
            active and passive. Passive healthchecks depend on failures in
            actual client traffic (e.g. RST from server in response to a client
            connection) to detect that the server or the application is down.
            In case of active healthchecks, load balancer itself initiates new
            connections (or sends ICMP ping) to the servers periodically to
            check their health, completely independent of any data traffic.
            Currently, active health monitors are supported for HTTP, HTTPS,
            TCP, UDP and ICMP protocols.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        """
        self.max_fails = max_fails
        self.timeout = timeout
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

LbPassiveMonitor._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_passive_monitor', {
        'max_fails': type.OptionalType(type.IntegerType()),
        'timeout': type.OptionalType(type.IntegerType()),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
    },
    LbPassiveMonitor,
    False,
    None))



class LbPersistenceCookieTime(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LbPersistenceCookieTime"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'cookie_max_idle': 'cookie_max_idle',
                            'type': 'type',
                            }

    def __init__(self,
                 cookie_max_idle=None,
                 type='LbPersistenceCookieTime',
                ):
        """
        :type  cookie_max_idle: :class:`long` or ``None``
        :param cookie_max_idle: HTTP cookie max-age to expire cookie, only available for insert
            mode. format: int64
        :type  type: :class:`str`
        :param type: Possible values are: 
            
            * :attr:`LbCookieTime.TYPE_LBSESSIONCOOKIETIME`
            * :attr:`LbCookieTime.TYPE_LBPERSISTENCECOOKIETIME`
            
            Both session cookie and persistence cookie are supported, Use
            LbSessionCookieTime for session cookie time setting, Use
            LbPersistenceCookieTime for persistence cookie time setting
        """
        self.cookie_max_idle = cookie_max_idle
        self._type = type
        VapiStruct.__init__(self)

    @property
    def type(self):
        """
        Return the discriminator value
        """
        return self._type

LbPersistenceCookieTime._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_persistence_cookie_time', {
        'cookie_max_idle': type.OptionalType(type.IntegerType()),
        'type': type.StringType(),
    },
    LbPersistenceCookieTime,
    False,
    None))



class LbPersistenceProfile(VapiStruct):
    """
    LB persistence profile contains the information related to load balancer
    persistence options. Some applications maintain state and require all
    relevant connections to be sent to the same server as the application state
    is not synchronized among servers. Persistence can be enabled on a
    LbVirtualServer by binding a persistence profile to it.
    LbGenericPersistenceProfile cannot be attached to virtual server directly,
    it can be only consumed by LB rule action. If a user attaches a generic
    persistence profile directly to a virtual server, the operation is
    rejected.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LbPersistenceProfile"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    RESOURCE_TYPE_LBCOOKIEPERSISTENCEPROFILE = "LbCookiePersistenceProfile"
    """


    """
    RESOURCE_TYPE_LBSOURCEIPPERSISTENCEPROFILE = "LbSourceIpPersistenceProfile"
    """


    """
    RESOURCE_TYPE_LBGENERICPERSISTENCEPROFILE = "LbGenericPersistenceProfile"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'persistence_shared': 'persistence_shared',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='LbPersistenceProfile',
                 tags=None,
                 persistence_shared=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            *
              :attr:`LbPersistenceProfile.RESOURCE_TYPE_LBCOOKIEPERSISTENCEPROFILE`
            *
              :attr:`LbPersistenceProfile.RESOURCE_TYPE_LBSOURCEIPPERSISTENCEPROFILE`
            *
              :attr:`LbPersistenceProfile.RESOURCE_TYPE_LBGENERICPERSISTENCEPROFILE`
            
             The resource_type property identifies persistence profile type.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  persistence_shared: :class:`bool` or ``None``
        :param persistence_shared: The persistence shared flag identifies whether the persistence
            table is shared among virtual-servers referring this profile. If
            persistence shared flag is not set in the cookie persistence
            profile bound to a virtual server, it defaults to cookie
            persistence that is private to each virtual server and is qualified
            by the pool. This is accomplished by load balancer inserting a
            cookie with name in the format
            <name>.<virtual_server_id>.<pool_id>. If persistence shared flag is
            set in the cookie persistence profile, in cookie insert mode,
            cookie persistence could be shared across multiple virtual servers
            that are bound to the same pools. The cookie name would be changed
            to <name>.<profile-id>.<pool-id>. If persistence shared flag is not
            set in the sourceIp persistence profile bound to a virtual server,
            each virtual server that the profile is bound to maintains its own
            private persistence table. If persistence shared flag is set in the
            sourceIp persistence profile, all virtual servers the profile is
            bound to share the same persistence table. If persistence shared
            flag is not set in the generic persistence profile, the persistence
            entries are matched and stored in the table which is identified
            using both virtual server ID and profile ID. If persistence shared
            flag is set in the generic persistence profile, the persistence
            entries are matched and stored in the table which is identified
            using profile ID. It means that virtual servers which consume the
            same profile in the LbRule with this flag enabled are sharing the
            same persistence table.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        self.persistence_shared = persistence_shared
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

LbPersistenceProfile._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_persistence_profile', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'persistence_shared': type.OptionalType(type.BooleanType()),
    },
    LbPersistenceProfile,
    False,
    None))



class LbPersistenceProfileListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param results: paginated list of load balancer persistence profiles
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`LbPersistenceProfile`. When methods return a value of this
            class as a return value, the attribute will contain all the
            attributes defined in :class:`LbPersistenceProfile`.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


LbPersistenceProfileListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_persistence_profile_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'LbPersistenceProfile')]))),
    },
    LbPersistenceProfileListResult,
    False,
    None))



class LbPool(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    ALGORITHM_ROUND_ROBIN = "ROUND_ROBIN"
    """


    """
    ALGORITHM_WEIGHTED_ROUND_ROBIN = "WEIGHTED_ROUND_ROBIN"
    """


    """
    ALGORITHM_LEAST_CONNECTION = "LEAST_CONNECTION"
    """


    """
    ALGORITHM_WEIGHTED_LEAST_CONNECTION = "WEIGHTED_LEAST_CONNECTION"
    """


    """
    ALGORITHM_IP_HASH = "IP_HASH"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'active_monitor_ids': 'active_monitor_ids',
                            'algorithm': 'algorithm',
                            'member_group': 'member_group',
                            'members': 'members',
                            'min_active_members': 'min_active_members',
                            'passive_monitor_id': 'passive_monitor_id',
                            'snat_translation': 'snat_translation',
                            'tcp_multiplexing_enabled': 'tcp_multiplexing_enabled',
                            'tcp_multiplexing_number': 'tcp_multiplexing_number',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 active_monitor_ids=None,
                 algorithm=None,
                 member_group=None,
                 members=None,
                 min_active_members=None,
                 passive_monitor_id=None,
                 snat_translation=None,
                 tcp_multiplexing_enabled=None,
                 tcp_multiplexing_number=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  active_monitor_ids: :class:`list` of :class:`str` or ``None``
        :param active_monitor_ids: In case of active healthchecks, load balancer itself initiates new
            connections (or sends ICMP ping) to the servers periodically to
            check their health, completely independent of any data traffic.
            Active healthchecks are disabled by default and can be enabled for
            a server pool by binding a health monitor to the pool. If multiple
            active monitors are configured, the pool member status is UP only
            when the health check status for all the monitors are UP.
        :type  algorithm: :class:`str` or ``None``
        :param algorithm: Possible values are: 
            
            * :attr:`LbPool.ALGORITHM_ROUND_ROBIN`
            * :attr:`LbPool.ALGORITHM_WEIGHTED_ROUND_ROBIN`
            * :attr:`LbPool.ALGORITHM_LEAST_CONNECTION`
            * :attr:`LbPool.ALGORITHM_WEIGHTED_LEAST_CONNECTION`
            * :attr:`LbPool.ALGORITHM_IP_HASH`
            
            Load balancing algorithm, configurable per pool controls how the
            incoming connections are distributed among the members.
        :type  member_group: :class:`PoolMemberGroup` or ``None``
        :param member_group: Load balancer pool support grouping object as dynamic pool members.
            When member group is defined, members setting should not be
            specified.
        :type  members: :class:`list` of :class:`PoolMember` or ``None``
        :param members: Server pool consists of one or more pool members. Each pool member
            is identified, typically, by an IP address and a port.
        :type  min_active_members: :class:`long` or ``None``
        :param min_active_members: A pool is considered active if there are at least certain minimum
            number of members. format: int64
        :type  passive_monitor_id: :class:`str` or ``None``
        :param passive_monitor_id: Passive healthchecks are disabled by default and can be enabled by
            attaching a passive health monitor to a server pool. Each time a
            client connection to a pool member fails, its failed count is
            incremented. For pools bound to L7 virtual servers, a connection is
            considered to be failed and failed count is incremented if any TCP
            connection errors (e.g. TCP RST or failure to send data) or SSL
            handshake failures occur. For pools bound to L4 virtual servers, if
            no response is received to a TCP SYN sent to the pool member or if
            a TCP RST is received in response to a TCP SYN, then the pool
            member is considered to have failed and the failed count is
            incremented.
        :type  snat_translation: :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param snat_translation: Depending on the topology, Source NAT (SNAT) may be required to
            ensure traffic from the server destined to the client is received
            by the load balancer. SNAT can be enabled per pool. If SNAT is not
            enabled for a pool, then load balancer uses the client IP and port
            (spoofing) while establishing connections to the servers. This is
            referred to as no-SNAT or TRANSPARENT mode.
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`LbSnatTranslation`. When methods return a value of this
            class as a return value, the attribute will contain all the
            attributes defined in :class:`LbSnatTranslation`.
        :type  tcp_multiplexing_enabled: :class:`bool` or ``None``
        :param tcp_multiplexing_enabled: TCP multiplexing allows the same TCP connection between load
            balancer and the backend server to be used for sending multiple
            client requests from different client TCP connections.
        :type  tcp_multiplexing_number: :class:`long` or ``None``
        :param tcp_multiplexing_number: The maximum number of TCP connections per pool that are idly kept
            alive for sending future client requests. format: int64
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.active_monitor_ids = active_monitor_ids
        self.algorithm = algorithm
        self.member_group = member_group
        self.members = members
        self.min_active_members = min_active_members
        self.passive_monitor_id = passive_monitor_id
        self.snat_translation = snat_translation
        self.tcp_multiplexing_enabled = tcp_multiplexing_enabled
        self.tcp_multiplexing_number = tcp_multiplexing_number
        VapiStruct.__init__(self)


LbPool._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_pool', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'active_monitor_ids': type.OptionalType(type.ListType(type.StringType())),
        'algorithm': type.OptionalType(type.StringType()),
        'member_group': type.OptionalType(type.ReferenceType(__name__, 'PoolMemberGroup')),
        'members': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'PoolMember'))),
        'min_active_members': type.OptionalType(type.IntegerType()),
        'passive_monitor_id': type.OptionalType(type.StringType()),
        'snat_translation': type.OptionalType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'LbSnatTranslation')])),
        'tcp_multiplexing_enabled': type.OptionalType(type.BooleanType()),
        'tcp_multiplexing_number': type.OptionalType(type.IntegerType()),
    },
    LbPool,
    False,
    None))



class LbPoolListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`LbPool` or ``None``
        :param results: paginated list of pools
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


LbPoolListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_pool_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'LbPool'))),
    },
    LbPoolListResult,
    False,
    None))



class LbPoolMemberStatistics(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'ip_address': 'ip_address',
                            'port': 'port',
                            'statistics': 'statistics',
                            }

    def __init__(self,
                 ip_address=None,
                 port=None,
                 statistics=None,
                ):
        """
        :type  ip_address: :class:`str` or ``None``
        :param ip_address: Pool member IP address format: ip
        :type  port: :class:`str` or ``None``
        :param port: The port is configured in pool member. For virtual server port
            range case, pool member port must be null. format: port-or-range
        :type  statistics: :class:`LbStatisticsCounter` or ``None``
        :param statistics: Pool member statistics counter
        """
        self.ip_address = ip_address
        self.port = port
        self.statistics = statistics
        VapiStruct.__init__(self)


LbPoolMemberStatistics._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_pool_member_statistics', {
        'ip_address': type.OptionalType(type.StringType()),
        'port': type.OptionalType(type.StringType()),
        'statistics': type.OptionalType(type.ReferenceType(__name__, 'LbStatisticsCounter')),
    },
    LbPoolMemberStatistics,
    False,
    None))



class LbPoolMemberStatus(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATUS_UP = "UP"
    """


    """
    STATUS_DOWN = "DOWN"
    """


    """
    STATUS_DISABLED = "DISABLED"
    """


    """
    STATUS_GRACEFUL_DISABLED = "GRACEFUL_DISABLED"
    """


    """
    STATUS_UNUSED = "UNUSED"
    """


    """
    STATUS_UNKNOWN = "UNKNOWN"
    """


    """



    _canonical_to_pep_names = {
                            'failure_cause': 'failure_cause',
                            'ip_address': 'ip_address',
                            'last_check_time': 'last_check_time',
                            'last_state_change_time': 'last_state_change_time',
                            'port': 'port',
                            'status': 'status',
                            }

    def __init__(self,
                 failure_cause=None,
                 ip_address=None,
                 last_check_time=None,
                 last_state_change_time=None,
                 port=None,
                 status=None,
                ):
        """
        :type  failure_cause: :class:`str` or ``None``
        :param failure_cause: If multiple active monitors are configured, the failure_cause
            contains failure cause for each monitors. Like
            \"Monitor_1:failure_cause_1. Monitor_2:failure_cause_2.\"
        :type  ip_address: :class:`str` or ``None``
        :param ip_address: Pool member IP address format: ip
        :type  last_check_time: :class:`long` or ``None``
        :param last_check_time: If multiple active monitors are configured, the property value is
            the latest last_check_time among all the monitors. format: int64
        :type  last_state_change_time: :class:`long` or ``None``
        :param last_state_change_time: If multiple active monitors are configured, the property value is
            the latest last_state_change_time among all the monitors. format:
            int64
        :type  port: :class:`str` or ``None``
        :param port: The port is configured in pool member. For virtual server port
            range case, pool member port must be null. format: port-or-range
        :type  status: :class:`str` or ``None``
        :param status: Possible values are: 
            
            * :attr:`LbPoolMemberStatus.STATUS_UP`
            * :attr:`LbPoolMemberStatus.STATUS_DOWN`
            * :attr:`LbPoolMemberStatus.STATUS_DISABLED`
            * :attr:`LbPoolMemberStatus.STATUS_GRACEFUL_DISABLED`
            * :attr:`LbPoolMemberStatus.STATUS_UNUSED`
            * :attr:`LbPoolMemberStatus.STATUS_UNKNOWN`
            
            UP means that pool member is enabled and monitors have marked the
            pool member as UP. If the pool member has no monitor configured, it
            would be treated as UP. DOWN means that pool member is enabled and
            monitors have marked the pool member as DOWN. DISABLED means that
            admin state of pool member is set to DISABLED. GRACEFUL_DISABLED
            means that admin state of pool member is set to GRACEFUL_DISABLED.
            UNUSED means that the pool member is not used when the IP list size
            of member group exceeds the maximum setting. The remaining IP
            addresses would not be used as available backend servers, hence
            mark the status as UNUSED. UNKNOWN means that the related pool is
            not associated to any enabled virtual servers, or no status
            reported from transport-nodes, the associated load balancer service
            may be working(or not working).
        """
        self.failure_cause = failure_cause
        self.ip_address = ip_address
        self.last_check_time = last_check_time
        self.last_state_change_time = last_state_change_time
        self.port = port
        self.status = status
        VapiStruct.__init__(self)


LbPoolMemberStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_pool_member_status', {
        'failure_cause': type.OptionalType(type.StringType()),
        'ip_address': type.OptionalType(type.StringType()),
        'last_check_time': type.OptionalType(type.IntegerType()),
        'last_state_change_time': type.OptionalType(type.IntegerType()),
        'port': type.OptionalType(type.StringType()),
        'status': type.OptionalType(type.StringType()),
    },
    LbPoolMemberStatus,
    False,
    None))



class LbPoolStatistics(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'last_update_timestamp': 'last_update_timestamp',
                            'members': 'members',
                            'pool_id': 'pool_id',
                            'statistics': 'statistics',
                            }

    def __init__(self,
                 last_update_timestamp=None,
                 members=None,
                 pool_id=None,
                 statistics=None,
                ):
        """
        :type  last_update_timestamp: :class:`long` or ``None``
        :param last_update_timestamp: Timestamp when the data was last updated format: int64
        :type  members: :class:`list` of :class:`LbPoolMemberStatistics` or ``None``
        :param members: Statistics of load balancer pool members
        :type  pool_id: :class:`str` or ``None``
        :param pool_id: Load balancer pool identifier
        :type  statistics: :class:`LbStatisticsCounter` or ``None``
        :param statistics: Virtual server statistics counter
        """
        self.last_update_timestamp = last_update_timestamp
        self.members = members
        self.pool_id = pool_id
        self.statistics = statistics
        VapiStruct.__init__(self)


LbPoolStatistics._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_pool_statistics', {
        'last_update_timestamp': type.OptionalType(type.IntegerType()),
        'members': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'LbPoolMemberStatistics'))),
        'pool_id': type.OptionalType(type.StringType()),
        'statistics': type.OptionalType(type.ReferenceType(__name__, 'LbStatisticsCounter')),
    },
    LbPoolStatistics,
    False,
    None))



class LbPoolStatisticsListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`LbPoolStatistics` or ``None``
        :param results: paginated statistics list of pools
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


LbPoolStatisticsListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_pool_statistics_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'LbPoolStatistics'))),
    },
    LbPoolStatisticsListResult,
    False,
    None))



class LbPoolStatus(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATUS_UP = "UP"
    """


    """
    STATUS_PARTIALLY_UP = "PARTIALLY_UP"
    """


    """
    STATUS_PRIMARY_DOWN = "PRIMARY_DOWN"
    """


    """
    STATUS_DOWN = "DOWN"
    """


    """
    STATUS_DETACHED = "DETACHED"
    """


    """
    STATUS_UNKNOWN = "UNKNOWN"
    """


    """



    _canonical_to_pep_names = {
                            'last_update_timestamp': 'last_update_timestamp',
                            'members': 'members',
                            'pool_id': 'pool_id',
                            'status': 'status',
                            }

    def __init__(self,
                 last_update_timestamp=None,
                 members=None,
                 pool_id=None,
                 status=None,
                ):
        """
        :type  last_update_timestamp: :class:`long` or ``None``
        :param last_update_timestamp: Timestamp when the data was last updated format: int64
        :type  members: :class:`list` of :class:`LbPoolMemberStatus` or ``None``
        :param members: Status of load balancer pool members
        :type  pool_id: :class:`str` or ``None``
        :param pool_id: Load balancer pool identifier
        :type  status: :class:`str` or ``None``
        :param status: Possible values are: 
            
            * :attr:`LbPoolStatus.STATUS_UP`
            * :attr:`LbPoolStatus.STATUS_PARTIALLY_UP`
            * :attr:`LbPoolStatus.STATUS_PRIMARY_DOWN`
            * :attr:`LbPoolStatus.STATUS_DOWN`
            * :attr:`LbPoolStatus.STATUS_DETACHED`
            * :attr:`LbPoolStatus.STATUS_UNKNOWN`
            
            UP means that all primary members are in UP status. PARTIALLY_UP
            means that some(not all) primary members are in UP status, the
            number of these active members is larger or equal to certain
            number(min_active_members) which is defined in LbPool. When there
            are no backup members which are in the UP status, the
            number(min_active_members) would be ignored. PRIMARY_DOWN means
            that less than certain(min_active_members) primary members are in
            UP status but backup members are in UP status, connections to this
            pool would be dispatched to backup members. DOWN means that all
            primary and backup members are DOWN. DETACHED means that the pool
            is not bound to any virtual server. UNKNOWN means that the pool is
            not associated to any enabled virtual servers, or no status
            reported from transport-nodes, the associated load balancer service
            may be working(or not working).
        """
        self.last_update_timestamp = last_update_timestamp
        self.members = members
        self.pool_id = pool_id
        self.status = status
        VapiStruct.__init__(self)


LbPoolStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_pool_status', {
        'last_update_timestamp': type.OptionalType(type.IntegerType()),
        'members': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'LbPoolMemberStatus'))),
        'pool_id': type.OptionalType(type.StringType()),
        'status': type.OptionalType(type.StringType()),
    },
    LbPoolStatus,
    False,
    None))



class LbPoolStatusListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`LbPoolStatus` or ``None``
        :param results: paginated status list of pools
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


LbPoolStatusListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_pool_status_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'LbPoolStatus'))),
    },
    LbPoolStatusListResult,
    False,
    None))



class LbRule(VapiStruct):
    """
    Load balancer rules allow customization of load balancing behavior using
    match/action rules. Currently, load balancer rules are supported for only
    layer 7 virtual servers with application profile LbHttpProfile. Each
    application rule consists of one or more match conditions and one or more
    actions. Load balancer rules could be used by different load balancer
    services.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    MATCH_STRATEGY_ALL = "ALL"
    """


    """
    MATCH_STRATEGY_ANY = "ANY"
    """


    """
    PHASE_HTTP_REQUEST_REWRITE = "HTTP_REQUEST_REWRITE"
    """


    """
    PHASE_HTTP_FORWARDING = "HTTP_FORWARDING"
    """


    """
    PHASE_HTTP_RESPONSE_REWRITE = "HTTP_RESPONSE_REWRITE"
    """


    """
    PHASE_HTTP_ACCESS = "HTTP_ACCESS"
    """


    """
    PHASE_TRANSPORT = "TRANSPORT"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'actions': 'actions',
                            'match_conditions': 'match_conditions',
                            'match_strategy': 'match_strategy',
                            'phase': 'phase',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 actions=None,
                 match_conditions=None,
                 match_strategy=None,
                 phase=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  actions: :class:`list` of :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param actions: A list of actions to be executed at specified phase when load
            balancer rule matches. The actions are used to manipulate
            application traffic, such as rewrite URI of HTTP messages, redirect
            HTTP messages, etc.
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`LbRuleAction`. When methods return a value of this class as
            a return value, the attribute will contain all the attributes
            defined in :class:`LbRuleAction`.
        :type  match_conditions: :class:`list` of :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param match_conditions: A list of match conditions used to match application traffic.
            Multiple match conditions can be specified in one load balancer
            rule, each match condition defines a criterion to match application
            traffic. If no match conditions are specified, then the load
            balancer rule will always match and it is used typically to define
            default rules. If more than one match condition is specified, then
            match strategy determines if all conditions should match or any one
            condition should match for the load balancer rule to considered a
            match.
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`LbRuleCondition`. When methods return a value of this class
            as a return value, the attribute will contain all the attributes
            defined in :class:`LbRuleCondition`.
        :type  match_strategy: :class:`str` or ``None``
        :param match_strategy: Possible values are: 
            
            * :attr:`LbRule.MATCH_STRATEGY_ALL`
            * :attr:`LbRule.MATCH_STRATEGY_ANY`
            
            Strategy to define how load balancer rule is considered a match
            when multiple match conditions are specified in one rule. If
            match_stragety is set to ALL, then load balancer rule is considered
            a match only if all the conditions match. If match_strategy is set
            to ANY, then load balancer rule is considered a match if any one of
            the conditions match.
        :type  phase: :class:`str` or ``None``
        :param phase: Possible values are: 
            
            * :attr:`LbRule.PHASE_HTTP_REQUEST_REWRITE`
            * :attr:`LbRule.PHASE_HTTP_FORWARDING`
            * :attr:`LbRule.PHASE_HTTP_RESPONSE_REWRITE`
            * :attr:`LbRule.PHASE_HTTP_ACCESS`
            * :attr:`LbRule.PHASE_TRANSPORT`
            
            Each load balancer rule is used at a specific phase of load
            balancer processing. Currently five phases are supported,
            HTTP_REQUEST_REWRITE, HTTP_FORWARDING, HTTP_RESPONSE_REWRITE,
            HTTP_ACCESS and TRANSPORT. When an HTTP request message is received
            by load balancer, all HTTP_REQUEST_REWRITE rules, if present are
            executed in the order they are applied to virtual server. And then
            if HTTP_FORWARDING rules present, only first matching rule's action
            is executed, remaining rules are not checked. HTTP_FORWARDING rules
            can have only one action. If the request is forwarded to a backend
            server and the response goes back to load balancer, all
            HTTP_RESPONSE_REWRITE rules, if present, are executed in the order
            they are applied to the virtual server. In HTTP_ACCESS phase, user
            can define action to control access using JWT authentication. In
            TRANSPORT phase, user can define the condition to match SNI in TLS
            client hello and define the action to do SSL end-to-end, SSL
            offloading or SSL passthrough using a specific load balancer server
            pool.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.actions = actions
        self.match_conditions = match_conditions
        self.match_strategy = match_strategy
        self.phase = phase
        VapiStruct.__init__(self)


LbRule._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_rule', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'actions': type.OptionalType(type.ListType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'LbRuleAction')]))),
        'match_conditions': type.OptionalType(type.ListType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'LbRuleCondition')]))),
        'match_strategy': type.OptionalType(type.StringType()),
        'phase': type.OptionalType(type.StringType()),
    },
    LbRule,
    False,
    None))



class LbRuleAction(VapiStruct):
    """
    Load balancer rule actions are used to manipulate application traffic.
    Currently load balancer rules can be used at three load balancer processing
    phases. Each phase has its own supported type of actions. Supported actions
    in HTTP_REQUST_REWRITE phase are: LbHttpRequestUriRewriteAction
    LbHttpRequestHeaderRewriteAction LbHttpRequestHeaderDeleteAction
    LbVariableAssignmentAction Supported actions in HTTP_FORWARDING phase are:
    LbHttpRejectAction LbHttpRedirectAction LbSelectPoolAction
    LbVariablePersistenceOnAction LbConnectionDropAction Supported action in
    HTTP_RESPONSE_REWRITE phase is: LbHttpResponseHeaderRewriteAction
    LbHttpResponseHeaderDeleteAction LbVariablePersistenceLearnAction Supported
    action in HTTP_ACCESS phase is: LbJwtAuthAction LbConnectionDropAction
    LbVariableAssignmentAction Supported action in TRANSPORT phase is:
    LbSslModeSelectionAction LbSelectPoolAction If the match type of an
    LbRuleCondition field is specified as REGEX and named capturing groups are
    used in the specified regular expression. The groups can be used as
    variables in LbRuleAction fields. For example, define a rule with
    LbHttpRequestUriCondition as match condition and
    LbHttpRequestUriRewriteAction as action. Set match_type field of
    LbHttpRequestUriCondition to REGEX, and set uri field to
    \"/news/(?&lt;year&gt;\\d+)/(?&lt;month&gt;\\d+)/(?&lt;article&gt;.\*)\".
    Set uri field of LbHttpRequestUriRewriteAction to:
    \"/news/$year-$month/$article\" In uri field of LbHttpRequestUriCondition,
    the (?&lt;year&gt;\\d+), (?&lt;month&gt;\\d+) and (?&lt;article&gt;.\*) are
    named capturing groups, they define variables named $year, $month and
    $article respectively. The defined variables are used in
    LbHttpRequestUriRewriteAction. For a matched HTTP request with URI
    \"/news/2017/06/xyz.html\", the substring \"2017\" is captured in variable
    $year, \"06\" is captured in variable $month, and \"xyz.html\" is captured
    in variable $article. The LbHttpRequestUriRewriteAction will rewrite the
    URI to: \"/news/2017-06/xyz.html\" A set of built-in variables can be used
    in LbRuleAction as well. The name of built-in variables start with
    underscore, the name of user defined variables is not allowed to start with
    underscore. Following are some of the built-in variables: $_scheme:
    Reference the scheme part of matched HTTP messages, could be \"http\" or
    \"https\". $_host: Host of matched HTTP messages, for example
    \"www.example.com\". $_server_port: Port part of URI, it is also the port
    of the server which accepted a request. Default port is 80 for http and 443
    for https. $_uri: The URI path, for example \"/products/sample.html\".
    $_request_uri: Full original request URI with arguments, for example,
    \"/products/sample.html?a=b&c=d\". $_args: URI arguments, for instance
    \"a=b&c=d\" $_is_args: \"?\" if a request has URI arguments, or an empty
    string otherwise. For the full list of built-in variables, please reference
    the NSX-T Administrator's Guide.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LbRuleAction"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    TYPE_LBHTTPREQUESTURIREWRITEACTION = "LbHttpRequestUriRewriteAction"
    """


    """
    TYPE_LBHTTPREQUESTHEADERREWRITEACTION = "LbHttpRequestHeaderRewriteAction"
    """


    """
    TYPE_LBHTTPREJECTACTION = "LbHttpRejectAction"
    """


    """
    TYPE_LBHTTPREDIRECTACTION = "LbHttpRedirectAction"
    """


    """
    TYPE_LBSELECTPOOLACTION = "LbSelectPoolAction"
    """


    """
    TYPE_LBSELECTSERVERACTION = "LbSelectServerAction"
    """


    """
    TYPE_LBHTTPRESPONSEHEADERREWRITEACTION = "LbHttpResponseHeaderRewriteAction"
    """


    """
    TYPE_LBHTTPREQUESTHEADERDELETEACTION = "LbHttpRequestHeaderDeleteAction"
    """


    """
    TYPE_LBHTTPRESPONSEHEADERDELETEACTION = "LbHttpResponseHeaderDeleteAction"
    """


    """
    TYPE_LBVARIABLEASSIGNMENTACTION = "LbVariableAssignmentAction"
    """


    """
    TYPE_LBVARIABLEPERSISTENCEONACTION = "LbVariablePersistenceOnAction"
    """


    """
    TYPE_LBVARIABLEPERSISTENCELEARNACTION = "LbVariablePersistenceLearnAction"
    """


    """
    TYPE_LBJWTAUTHACTION = "LbJwtAuthAction"
    """


    """
    TYPE_LBSSLMODESELECTIONACTION = "LbSslModeSelectionAction"
    """


    """
    TYPE_LBCONNECTIONDROPACTION = "LbConnectionDropAction"
    """


    """



    _canonical_to_pep_names = {
                            'type': 'type',
                            }

    def __init__(self,
                 type='LbRuleAction',
                ):
        """
        :type  type: :class:`str`
        :param type: Possible values are: 
            
            * :attr:`LbRuleAction.TYPE_LBHTTPREQUESTURIREWRITEACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPREQUESTHEADERREWRITEACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPREJECTACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPREDIRECTACTION`
            * :attr:`LbRuleAction.TYPE_LBSELECTPOOLACTION`
            * :attr:`LbRuleAction.TYPE_LBSELECTSERVERACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPRESPONSEHEADERREWRITEACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPREQUESTHEADERDELETEACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPRESPONSEHEADERDELETEACTION`
            * :attr:`LbRuleAction.TYPE_LBVARIABLEASSIGNMENTACTION`
            * :attr:`LbRuleAction.TYPE_LBVARIABLEPERSISTENCEONACTION`
            * :attr:`LbRuleAction.TYPE_LBVARIABLEPERSISTENCELEARNACTION`
            * :attr:`LbRuleAction.TYPE_LBJWTAUTHACTION`
            * :attr:`LbRuleAction.TYPE_LBSSLMODESELECTIONACTION`
            * :attr:`LbRuleAction.TYPE_LBCONNECTIONDROPACTION`
            
             The property identifies the load balancer rule action type.
        """
        self._type = type
        VapiStruct.__init__(self)

    @property
    def type(self):
        """
        Return the discriminator value
        """
        return self._type

LbRuleAction._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_rule_action', {
        'type': type.StringType(),
    },
    LbRuleAction,
    False,
    None))



class LbRuleCondition(VapiStruct):
    """
    Match conditions are used to match application traffic passing through load
    balancers. Multiple match conditions can be specified in one load balancer
    rule, each match condition defines a criterion for application traffic. If
    inverse field is set to true, the match result of the condition is
    inverted. If more than one match condition is specified, match strategy
    determines if all conditions should match or any one condition should match
    for the load balancer rule to be considered a match. Currently only HTTP
    messages are supported by load balancer rules. Each load balancer rule is
    used at a specific phase of load balancer processing. Currently three
    phases are supported, HTTP_REQUEST_REWRITE, HTTP_FORWARDING and
    HTTP_RESPONSE_REWRITE. Each phase supports certain types of match
    conditions, supported match conditions in HTTP_REQUEST_REWRITE phase are:
    LbHttpRequestMethodCondition LbHttpRequestUriCondition
    LbHttpRequestUriArgumentsCondition LbHttpRequestVersionCondition
    LbHttpRequestHeaderCondition LbHttpRequestCookieCondition
    LbHttpRequestBodyCondition LbTcpHeaderCondition LbIpHeaderCondition
    LbVariableCondition LbHttpSslCondition Supported match conditions in
    HTTP_FORWARDING phase are: LbHttpRequestMethodCondition
    LbHttpRequestUriCondition LbHttpRequestUriArgumentsCondition
    LbHttpRequestVersionCondition LbHttpRequestHeaderCondition
    LbHttpRequestCookieCondition LbHttpRequestBodyCondition
    LbTcpHeaderCondition LbIpHeaderCondition LbVariableCondition
    LbHttpSslCondition LbSslSniCondition Supported match condition in
    HTTP_RESPONSE_REWRITE phase is: LbHttpResponseHeaderCondition
    LbHttpRequestMethodCondition LbHttpRequestUriCondition
    LbHttpRequestUriArgumentsCondition LbHttpRequestVersionCondition
    LbHttpRequestHeaderCondition LbHttpRequestCookieCondition
    LbTcpHeaderCondition LbIpHeaderCondition LbVariableCondition
    LbHttpSslCondition Supported match condition in HTTP_ACCESS phase is:
    LbHttpRequestMethodCondition LbHttpRequestUriCondition
    LbHttpRequestUriArgumentsCondition LbHttpRequestVersionCondition
    LbHttpRequestHeaderCondition LbHttpRequestCookieCondition
    LbHttpRequestBodyCondition LbTcpHeaderCondition LbIpHeaderCondition
    LbVariableCondition LbHttpSslCondition Supported match condition in
    TRANSPORT phase is: LbSslSniCondition

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LbRuleCondition"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    TYPE_LBHTTPREQUESTMETHODCONDITION = "LbHttpRequestMethodCondition"
    """


    """
    TYPE_LBHTTPREQUESTURICONDITION = "LbHttpRequestUriCondition"
    """


    """
    TYPE_LBHTTPREQUESTURIARGUMENTSCONDITION = "LbHttpRequestUriArgumentsCondition"
    """


    """
    TYPE_LBHTTPREQUESTVERSIONCONDITION = "LbHttpRequestVersionCondition"
    """


    """
    TYPE_LBHTTPREQUESTHEADERCONDITION = "LbHttpRequestHeaderCondition"
    """


    """
    TYPE_LBHTTPREQUESTCOOKIECONDITION = "LbHttpRequestCookieCondition"
    """


    """
    TYPE_LBHTTPREQUESTBODYCONDITION = "LbHttpRequestBodyCondition"
    """


    """
    TYPE_LBHTTPRESPONSEHEADERCONDITION = "LbHttpResponseHeaderCondition"
    """


    """
    TYPE_LBTCPHEADERCONDITION = "LbTcpHeaderCondition"
    """


    """
    TYPE_LBIPHEADERCONDITION = "LbIpHeaderCondition"
    """


    """
    TYPE_LBVARIABLECONDITION = "LbVariableCondition"
    """


    """
    TYPE_LBHTTPSSLCONDITION = "LbHttpSslCondition"
    """


    """
    TYPE_LBSSLSNICONDITION = "LbSslSniCondition"
    """


    """



    _canonical_to_pep_names = {
                            'inverse': 'inverse',
                            'type': 'type',
                            }

    def __init__(self,
                 inverse=None,
                 type='LbRuleCondition',
                ):
        """
        :type  inverse: :class:`bool` or ``None``
        :param inverse: A flag to indicate whether reverse the match result of this
            condition
        :type  type: :class:`str`
        :param type: Possible values are: 
            
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTMETHODCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTURICONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTURIARGUMENTSCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTVERSIONCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTHEADERCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTCOOKIECONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTBODYCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPRESPONSEHEADERCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBTCPHEADERCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBIPHEADERCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBVARIABLECONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPSSLCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBSSLSNICONDITION`
            
             Type of load balancer rule condition
        """
        self.inverse = inverse
        self._type = type
        VapiStruct.__init__(self)

    @property
    def type(self):
        """
        Return the discriminator value
        """
        return self._type

LbRuleCondition._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_rule_condition', {
        'inverse': type.OptionalType(type.BooleanType()),
        'type': type.StringType(),
    },
    LbRuleCondition,
    False,
    None))



class LbRuleListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`LbRule` or ``None``
        :param results: paginated list of LB rules
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


LbRuleListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_rule_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'LbRule'))),
    },
    LbRuleListResult,
    False,
    None))



class LbSelectPoolAction(VapiStruct):
    """
    This action is used to select a pool for matched HTTP request messages. The
    pool is specified by UUID. The matched HTTP request messages are forwarded
    to the specified pool.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LbSelectPoolAction"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'pool_id': 'pool_id',
                            'pool_name': 'pool_name',
                            'type': 'type',
                            }

    def __init__(self,
                 pool_id=None,
                 pool_name=None,
                 type='LbSelectPoolAction',
                ):
        """
        :type  pool_id: :class:`str` or ``None``
        :param pool_id: UUID of load balancer pool
        :type  pool_name: :class:`str` or ``None``
        :param pool_name: Display name of load balancer pool
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  type: :class:`str`
        :param type: Possible values are: 
            
            * :attr:`LbRuleAction.TYPE_LBHTTPREQUESTURIREWRITEACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPREQUESTHEADERREWRITEACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPREJECTACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPREDIRECTACTION`
            * :attr:`LbRuleAction.TYPE_LBSELECTPOOLACTION`
            * :attr:`LbRuleAction.TYPE_LBSELECTSERVERACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPRESPONSEHEADERREWRITEACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPREQUESTHEADERDELETEACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPRESPONSEHEADERDELETEACTION`
            * :attr:`LbRuleAction.TYPE_LBVARIABLEASSIGNMENTACTION`
            * :attr:`LbRuleAction.TYPE_LBVARIABLEPERSISTENCEONACTION`
            * :attr:`LbRuleAction.TYPE_LBVARIABLEPERSISTENCELEARNACTION`
            * :attr:`LbRuleAction.TYPE_LBJWTAUTHACTION`
            * :attr:`LbRuleAction.TYPE_LBSSLMODESELECTIONACTION`
            * :attr:`LbRuleAction.TYPE_LBCONNECTIONDROPACTION`
            
             The property identifies the load balancer rule action type.
        """
        self.pool_id = pool_id
        self.pool_name = pool_name
        self._type = type
        VapiStruct.__init__(self)

    @property
    def type(self):
        """
        Return the discriminator value
        """
        return self._type

LbSelectPoolAction._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_select_pool_action', {
        'pool_id': type.OptionalType(type.StringType()),
        'pool_name': type.OptionalType(type.StringType()),
        'type': type.StringType(),
    },
    LbSelectPoolAction,
    False,
    None))



class LbServerSslProfile(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    CIPHER_GROUP_LABEL_BALANCED = "BALANCED"
    """


    """
    CIPHER_GROUP_LABEL_HIGH_SECURITY = "HIGH_SECURITY"
    """


    """
    CIPHER_GROUP_LABEL_HIGH_COMPATIBILITY = "HIGH_COMPATIBILITY"
    """


    """
    CIPHER_GROUP_LABEL_CUSTOM = "CUSTOM"
    """


    """
    CIPHERS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 = "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256"
    """


    """
    CIPHERS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 = "TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384"
    """


    """
    CIPHERS_ECDHE_RSA_WITH_AES_256_CBC_SHA = "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA"
    """


    """
    CIPHERS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA = "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA"
    """


    """
    CIPHERS_ECDH_ECDSA_WITH_AES_256_CBC_SHA = "TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA"
    """


    """
    CIPHERS_ECDH_RSA_WITH_AES_256_CBC_SHA = "TLS_ECDH_RSA_WITH_AES_256_CBC_SHA"
    """


    """
    CIPHERS_RSA_WITH_AES_256_CBC_SHA = "TLS_RSA_WITH_AES_256_CBC_SHA"
    """


    """
    CIPHERS_RSA_WITH_AES_128_CBC_SHA = "TLS_RSA_WITH_AES_128_CBC_SHA"
    """


    """
    CIPHERS_RSA_WITH_3DES_EDE_CBC_SHA = "TLS_RSA_WITH_3DES_EDE_CBC_SHA"
    """


    """
    CIPHERS_ECDHE_RSA_WITH_AES_128_CBC_SHA = "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA"
    """


    """
    CIPHERS_ECDHE_RSA_WITH_AES_128_CBC_SHA256 = "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256"
    """


    """
    CIPHERS_ECDHE_RSA_WITH_AES_256_CBC_SHA384 = "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384"
    """


    """
    CIPHERS_RSA_WITH_AES_128_CBC_SHA256 = "TLS_RSA_WITH_AES_128_CBC_SHA256"
    """


    """
    CIPHERS_RSA_WITH_AES_128_GCM_SHA256 = "TLS_RSA_WITH_AES_128_GCM_SHA256"
    """


    """
    CIPHERS_RSA_WITH_AES_256_CBC_SHA256 = "TLS_RSA_WITH_AES_256_CBC_SHA256"
    """


    """
    CIPHERS_RSA_WITH_AES_256_GCM_SHA384 = "TLS_RSA_WITH_AES_256_GCM_SHA384"
    """


    """
    CIPHERS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA = "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA"
    """


    """
    CIPHERS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256 = "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256"
    """


    """
    CIPHERS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 = "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256"
    """


    """
    CIPHERS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384 = "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384"
    """


    """
    CIPHERS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384 = "TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384"
    """


    """
    CIPHERS_ECDH_ECDSA_WITH_AES_128_CBC_SHA = "TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA"
    """


    """
    CIPHERS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256 = "TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256"
    """


    """
    CIPHERS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256 = "TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256"
    """


    """
    CIPHERS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384 = "TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384"
    """


    """
    CIPHERS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384 = "TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384"
    """


    """
    CIPHERS_ECDH_RSA_WITH_AES_128_CBC_SHA = "TLS_ECDH_RSA_WITH_AES_128_CBC_SHA"
    """


    """
    CIPHERS_ECDH_RSA_WITH_AES_128_CBC_SHA256 = "TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256"
    """


    """
    CIPHERS_ECDH_RSA_WITH_AES_128_GCM_SHA256 = "TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256"
    """


    """
    CIPHERS_ECDH_RSA_WITH_AES_256_CBC_SHA384 = "TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384"
    """


    """
    CIPHERS_ECDH_RSA_WITH_AES_256_GCM_SHA384 = "TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384"
    """


    """
    PROTOCOLS_SSL_V2 = "SSL_V2"
    """


    """
    PROTOCOLS_SSL_V3 = "SSL_V3"
    """


    """
    PROTOCOLS_TLS_V1 = "TLS_V1"
    """


    """
    PROTOCOLS_TLS_V1_1 = "TLS_V1_1"
    """


    """
    PROTOCOLS_TLS_V1_2 = "TLS_V1_2"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'cipher_group_label': 'cipher_group_label',
                            'ciphers': 'ciphers',
                            'is_fips': 'is_fips',
                            'is_secure': 'is_secure',
                            'protocols': 'protocols',
                            'session_cache_enabled': 'session_cache_enabled',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 cipher_group_label=None,
                 ciphers=None,
                 is_fips=None,
                 is_secure=None,
                 protocols=None,
                 session_cache_enabled=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  cipher_group_label: :class:`str` or ``None``
        :param cipher_group_label: Possible values are: 
            
            * :attr:`LbServerSslProfile.CIPHER_GROUP_LABEL_BALANCED`
            * :attr:`LbServerSslProfile.CIPHER_GROUP_LABEL_HIGH_SECURITY`
            * :attr:`LbServerSslProfile.CIPHER_GROUP_LABEL_HIGH_COMPATIBILITY`
            * :attr:`LbServerSslProfile.CIPHER_GROUP_LABEL_CUSTOM`
            
             It is a label of cipher group which is mostly consumed by GUI.
        :type  ciphers: :class:`list` of :class:`str` or ``None``
        :param ciphers: Possible values are: 
            
            *
              :attr:`LbServerSslProfile.CIPHERS_ECDHE_RSA_WITH_AES_128_GCM_SHA256`
            *
              :attr:`LbServerSslProfile.CIPHERS_ECDHE_RSA_WITH_AES_256_GCM_SHA384`
            * :attr:`LbServerSslProfile.CIPHERS_ECDHE_RSA_WITH_AES_256_CBC_SHA`
            *
              :attr:`LbServerSslProfile.CIPHERS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA`
            *
              :attr:`LbServerSslProfile.CIPHERS_ECDH_ECDSA_WITH_AES_256_CBC_SHA`
            * :attr:`LbServerSslProfile.CIPHERS_ECDH_RSA_WITH_AES_256_CBC_SHA`
            * :attr:`LbServerSslProfile.CIPHERS_RSA_WITH_AES_256_CBC_SHA`
            * :attr:`LbServerSslProfile.CIPHERS_RSA_WITH_AES_128_CBC_SHA`
            * :attr:`LbServerSslProfile.CIPHERS_RSA_WITH_3DES_EDE_CBC_SHA`
            * :attr:`LbServerSslProfile.CIPHERS_ECDHE_RSA_WITH_AES_128_CBC_SHA`
            *
              :attr:`LbServerSslProfile.CIPHERS_ECDHE_RSA_WITH_AES_128_CBC_SHA256`
            *
              :attr:`LbServerSslProfile.CIPHERS_ECDHE_RSA_WITH_AES_256_CBC_SHA384`
            * :attr:`LbServerSslProfile.CIPHERS_RSA_WITH_AES_128_CBC_SHA256`
            * :attr:`LbServerSslProfile.CIPHERS_RSA_WITH_AES_128_GCM_SHA256`
            * :attr:`LbServerSslProfile.CIPHERS_RSA_WITH_AES_256_CBC_SHA256`
            * :attr:`LbServerSslProfile.CIPHERS_RSA_WITH_AES_256_GCM_SHA384`
            *
              :attr:`LbServerSslProfile.CIPHERS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA`
            *
              :attr:`LbServerSslProfile.CIPHERS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256`
            *
              :attr:`LbServerSslProfile.CIPHERS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256`
            *
              :attr:`LbServerSslProfile.CIPHERS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384`
            *
              :attr:`LbServerSslProfile.CIPHERS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384`
            *
              :attr:`LbServerSslProfile.CIPHERS_ECDH_ECDSA_WITH_AES_128_CBC_SHA`
            *
              :attr:`LbServerSslProfile.CIPHERS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256`
            *
              :attr:`LbServerSslProfile.CIPHERS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256`
            *
              :attr:`LbServerSslProfile.CIPHERS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384`
            *
              :attr:`LbServerSslProfile.CIPHERS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384`
            * :attr:`LbServerSslProfile.CIPHERS_ECDH_RSA_WITH_AES_128_CBC_SHA`
            *
              :attr:`LbServerSslProfile.CIPHERS_ECDH_RSA_WITH_AES_128_CBC_SHA256`
            *
              :attr:`LbServerSslProfile.CIPHERS_ECDH_RSA_WITH_AES_128_GCM_SHA256`
            *
              :attr:`LbServerSslProfile.CIPHERS_ECDH_RSA_WITH_AES_256_CBC_SHA384`
            *
              :attr:`LbServerSslProfile.CIPHERS_ECDH_RSA_WITH_AES_256_GCM_SHA384`
            
             supported SSL cipher list to client side
        :type  is_fips: :class:`bool` or ``None``
        :param is_fips: This flag is set to true when all the ciphers and protocols are
            FIPS compliant. It is set to false when one of the ciphers or
            protocols are not FIPS compliant.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  is_secure: :class:`bool` or ``None``
        :param is_secure: This flag is set to true when all the ciphers and protocols are
            secure. It is set to false when one of the ciphers or protocols is
            insecure.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protocols: :class:`list` of :class:`str` or ``None``
        :param protocols: Possible values are: 
            
            * :attr:`LbServerSslProfile.PROTOCOLS_SSL_V2`
            * :attr:`LbServerSslProfile.PROTOCOLS_SSL_V3`
            * :attr:`LbServerSslProfile.PROTOCOLS_TLS_V1`
            * :attr:`LbServerSslProfile.PROTOCOLS_TLS_V1_1`
            * :attr:`LbServerSslProfile.PROTOCOLS_TLS_V1_2`
            
            SSL versions TLS1.1 and TLS1.2 are supported and enabled by
            default. SSLv2, SSLv3, and TLS1.0 are supported, but disabled by
            default.
        :type  session_cache_enabled: :class:`bool` or ``None``
        :param session_cache_enabled: SSL session caching allows SSL client and server to reuse
            previously negotiated security parameters avoiding the expensive
            public key operation during handshake.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.cipher_group_label = cipher_group_label
        self.ciphers = ciphers
        self.is_fips = is_fips
        self.is_secure = is_secure
        self.protocols = protocols
        self.session_cache_enabled = session_cache_enabled
        VapiStruct.__init__(self)


LbServerSslProfile._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_server_ssl_profile', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'cipher_group_label': type.OptionalType(type.StringType()),
        'ciphers': type.OptionalType(type.ListType(type.StringType())),
        'is_fips': type.OptionalType(type.BooleanType()),
        'is_secure': type.OptionalType(type.BooleanType()),
        'protocols': type.OptionalType(type.ListType(type.StringType())),
        'session_cache_enabled': type.OptionalType(type.BooleanType()),
    },
    LbServerSslProfile,
    False,
    None))



class LbServerSslProfileListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`LbServerSslProfile` or ``None``
        :param results: paginated list of load balancer server SSL profiles
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


LbServerSslProfileListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_server_ssl_profile_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'LbServerSslProfile'))),
    },
    LbServerSslProfileListResult,
    False,
    None))



class LbService(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    ERROR_LOG_LEVEL_DEBUG = "DEBUG"
    """


    """
    ERROR_LOG_LEVEL_INFO = "INFO"
    """


    """
    ERROR_LOG_LEVEL_WARNING = "WARNING"
    """


    """
    ERROR_LOG_LEVEL_ERROR = "ERROR"
    """


    """
    ERROR_LOG_LEVEL_CRITICAL = "CRITICAL"
    """


    """
    ERROR_LOG_LEVEL_ALERT = "ALERT"
    """


    """
    ERROR_LOG_LEVEL_EMERGENCY = "EMERGENCY"
    """


    """
    SIZE_SMALL = "SMALL"
    """


    """
    SIZE_MEDIUM = "MEDIUM"
    """


    """
    SIZE_LARGE = "LARGE"
    """


    """
    SIZE_XLARGE = "XLARGE"
    """


    """
    SIZE_DLB = "DLB"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'access_log_enabled': 'access_log_enabled',
                            'attachment': 'attachment',
                            'enabled': 'enabled',
                            'error_log_level': 'error_log_level',
                            'relax_scale_validation': 'relax_scale_validation',
                            'size': 'size',
                            'virtual_server_ids': 'virtual_server_ids',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 access_log_enabled=None,
                 attachment=None,
                 enabled=None,
                 error_log_level=None,
                 relax_scale_validation=None,
                 size=None,
                 virtual_server_ids=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  access_log_enabled: :class:`bool` or ``None``
        :param access_log_enabled: Whether access log is enabled
        :type  attachment: :class:`ResourceReference` or ``None``
        :param attachment: LBS could be instantiated (or created) on the Logical router, etc.
            Typically, it could be applied to Tier1 LogicalRouter. It can be
            attached to Tier0 LogicalRouter either in non-multi-tenant
            environments or to provide load balancing for infrastructure
            services offered by the provider. If size is set to DLB for
            distribution, the attachment is optional. The supported attachment
            is NSGroup consisting of VIFs of that load balancer's clients. If
            the attachment is not specified and size is DLB, the associated
            load balancer settings are applied to all supported transport
            nodes.
        :type  enabled: :class:`bool` or ``None``
        :param enabled: Whether the load balancer service is enabled
        :type  error_log_level: :class:`str` or ``None``
        :param error_log_level: Possible values are: 
            
            * :attr:`LbService.ERROR_LOG_LEVEL_DEBUG`
            * :attr:`LbService.ERROR_LOG_LEVEL_INFO`
            * :attr:`LbService.ERROR_LOG_LEVEL_WARNING`
            * :attr:`LbService.ERROR_LOG_LEVEL_ERROR`
            * :attr:`LbService.ERROR_LOG_LEVEL_CRITICAL`
            * :attr:`LbService.ERROR_LOG_LEVEL_ALERT`
            * :attr:`LbService.ERROR_LOG_LEVEL_EMERGENCY`
            
            Load balancer engine writes information about encountered issues of
            different severity levels to the error log. This setting is used to
            define the severity level of the error log.
        :type  relax_scale_validation: :class:`bool` or ``None``
        :param relax_scale_validation: If relax_scale_validation is true, the scale validations for
            virtual servers/pools/pool members/rules are relaxed for load
            balancer service. When load balancer service is deployed on edge
            nodes, the scale of virtual servers/pools/pool members for the load
            balancer service should not exceed the scale number of the largest
            load balancer size which could be configured on a certain edge form
            factor. For example, the largest load balancer size supported on a
            MEDIUM edge node is MEDIUM. So one SMALL load balancer deployed on
            MEDIUM edge nodes can support the scale number of MEDIUM load
            balancer. It is not recommended to enable active monitors if
            relax_scale_validation is true due to performance consideration. If
            relax_scale_validation is false, scale numbers should be validated
            for load balancer service.
        :type  size: :class:`str` or ``None``
        :param size: Possible values are: 
            
            * :attr:`LbService.SIZE_SMALL`
            * :attr:`LbService.SIZE_MEDIUM`
            * :attr:`LbService.SIZE_LARGE`
            * :attr:`LbService.SIZE_XLARGE`
            * :attr:`LbService.SIZE_DLB`
            
             The size of load balancer service
        :type  virtual_server_ids: :class:`list` of :class:`str` or ``None``
        :param virtual_server_ids: virtual servers can be associated to LbService(which is similar to
            physical/virtual load balancer), Lb virtual servers, pools and
            other entities could be defined independently, the virtual server
            identifier list here would be used to maintain the relationship of
            LbService and other Lb entities.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.access_log_enabled = access_log_enabled
        self.attachment = attachment
        self.enabled = enabled
        self.error_log_level = error_log_level
        self.relax_scale_validation = relax_scale_validation
        self.size = size
        self.virtual_server_ids = virtual_server_ids
        VapiStruct.__init__(self)


LbService._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_service', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'access_log_enabled': type.OptionalType(type.BooleanType()),
        'attachment': type.OptionalType(type.ReferenceType(__name__, 'ResourceReference')),
        'enabled': type.OptionalType(type.BooleanType()),
        'error_log_level': type.OptionalType(type.StringType()),
        'relax_scale_validation': type.OptionalType(type.BooleanType()),
        'size': type.OptionalType(type.StringType()),
        'virtual_server_ids': type.OptionalType(type.ListType(type.StringType())),
    },
    LbService,
    False,
    None))



class LbServiceDebugInfo(VapiStruct):
    """
    The information for a given load balancer service could be used for
    debugging and troubleshooting. It includes load balancer service,
    associated virtual servers, associated pools, associated profiles such as
    persistence, SSL, application, associated monitors and associated rules.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'application_profiles': 'application_profiles',
                            'client_ssl_profiles': 'client_ssl_profiles',
                            'monitors': 'monitors',
                            'persistence_profiles': 'persistence_profiles',
                            'pools': 'pools',
                            'rules': 'rules',
                            'server_ssl_profiles': 'server_ssl_profiles',
                            'service': 'service',
                            'tcp_profiles': 'tcp_profiles',
                            'virtual_servers': 'virtual_servers',
                            }

    def __init__(self,
                 application_profiles=None,
                 client_ssl_profiles=None,
                 monitors=None,
                 persistence_profiles=None,
                 pools=None,
                 rules=None,
                 server_ssl_profiles=None,
                 service=None,
                 tcp_profiles=None,
                 virtual_servers=None,
                ):
        """
        :type  application_profiles: :class:`list` of :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param application_profiles: The application profiles are associated to virtual servers
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`LbAppProfile`. When methods return a value of this class as
            a return value, the attribute will contain all the attributes
            defined in :class:`LbAppProfile`.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  client_ssl_profiles: :class:`list` of :class:`LbClientSslProfile` or ``None``
        :param client_ssl_profiles: The client SSL profiles are associated to virtual servers
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  monitors: :class:`list` of :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param monitors: The load balancer monitors are associated to pools.
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`LbMonitor`. When methods return a value of this class as a
            return value, the attribute will contain all the attributes defined
            in :class:`LbMonitor`.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  persistence_profiles: :class:`list` of :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param persistence_profiles: The persistence profiles are associated to virtual servers
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`LbPersistenceProfile`. When methods return a value of this
            class as a return value, the attribute will contain all the
            attributes defined in :class:`LbPersistenceProfile`.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  pools: :class:`list` of :class:`LbPool` or ``None``
        :param pools: The pools which are associated to the given load balancer service
            would be included. The pools could be defined in virtual server
            default pool, sorry pool or load balancer rule action.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  rules: :class:`list` of :class:`LbRule` or ``None``
        :param rules: The load balancer rules are associated to virtual servers
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  server_ssl_profiles: :class:`list` of :class:`LbServerSslProfile` or ``None``
        :param server_ssl_profiles: The server SSL profiles are associated to virtual servers
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  service: :class:`LbService` or ``None``
        :param service: Load balancer service setting for a given load balancer service
            identifier.
        :type  tcp_profiles: :class:`list` of :class:`LbTcpProfile` or ``None``
        :param tcp_profiles: The TCP profiles are associated to virtual servers
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  virtual_servers: :class:`list` of :class:`LbVirtualServer` or ``None``
        :param virtual_servers: The virtual servers which are associated to the given load balancer
            service would be included.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.application_profiles = application_profiles
        self.client_ssl_profiles = client_ssl_profiles
        self.monitors = monitors
        self.persistence_profiles = persistence_profiles
        self.pools = pools
        self.rules = rules
        self.server_ssl_profiles = server_ssl_profiles
        self.service = service
        self.tcp_profiles = tcp_profiles
        self.virtual_servers = virtual_servers
        VapiStruct.__init__(self)


LbServiceDebugInfo._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_service_debug_info', {
        'application_profiles': type.OptionalType(type.ListType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'LbAppProfile')]))),
        'client_ssl_profiles': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'LbClientSslProfile'))),
        'monitors': type.OptionalType(type.ListType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'LbMonitor')]))),
        'persistence_profiles': type.OptionalType(type.ListType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'LbPersistenceProfile')]))),
        'pools': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'LbPool'))),
        'rules': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'LbRule'))),
        'server_ssl_profiles': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'LbServerSslProfile'))),
        'service': type.OptionalType(type.ReferenceType(__name__, 'LbService')),
        'tcp_profiles': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'LbTcpProfile'))),
        'virtual_servers': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'LbVirtualServer'))),
    },
    LbServiceDebugInfo,
    False,
    None))



class LbServiceListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`LbService` or ``None``
        :param results: paginated list of load balancer services
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


LbServiceListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_service_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'LbService'))),
    },
    LbServiceListResult,
    False,
    None))



class LbServiceStatistics(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'last_update_timestamp': 'last_update_timestamp',
                            'pools': 'pools',
                            'service_id': 'service_id',
                            'statistics': 'statistics',
                            'virtual_servers': 'virtual_servers',
                            }

    def __init__(self,
                 last_update_timestamp=None,
                 pools=None,
                 service_id=None,
                 statistics=None,
                 virtual_servers=None,
                ):
        """
        :type  last_update_timestamp: :class:`long` or ``None``
        :param last_update_timestamp: Timestamp when the data was last updated format: int64
        :type  pools: :class:`list` of :class:`LbPoolStatistics` or ``None``
        :param pools: Statistics of load balancer pools
        :type  service_id: :class:`str` or ``None``
        :param service_id: load balancer service identifier
        :type  statistics: :class:`LbServiceStatisticsCounter` or ``None``
        :param statistics: Load balancer service statistics counter
        :type  virtual_servers: :class:`list` of :class:`LbVirtualServerStatistics` or ``None``
        :param virtual_servers: Statistics of load balancer virtual servers
        """
        self.last_update_timestamp = last_update_timestamp
        self.pools = pools
        self.service_id = service_id
        self.statistics = statistics
        self.virtual_servers = virtual_servers
        VapiStruct.__init__(self)


LbServiceStatistics._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_service_statistics', {
        'last_update_timestamp': type.OptionalType(type.IntegerType()),
        'pools': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'LbPoolStatistics'))),
        'service_id': type.OptionalType(type.StringType()),
        'statistics': type.OptionalType(type.ReferenceType(__name__, 'LbServiceStatisticsCounter')),
        'virtual_servers': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'LbVirtualServerStatistics'))),
    },
    LbServiceStatistics,
    False,
    None))



class LbServiceStatisticsCounter(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'l4_current_session_rate': 'l4_current_session_rate',
                            'l4_current_sessions': 'l4_current_sessions',
                            'l4_max_sessions': 'l4_max_sessions',
                            'l4_total_sessions': 'l4_total_sessions',
                            'l7_current_session_rate': 'l7_current_session_rate',
                            'l7_current_sessions': 'l7_current_sessions',
                            'l7_max_sessions': 'l7_max_sessions',
                            'l7_total_sessions': 'l7_total_sessions',
                            }

    def __init__(self,
                 l4_current_session_rate=None,
                 l4_current_sessions=None,
                 l4_max_sessions=None,
                 l4_total_sessions=None,
                 l7_current_session_rate=None,
                 l7_current_sessions=None,
                 l7_max_sessions=None,
                 l7_total_sessions=None,
                ):
        """
        :type  l4_current_session_rate: :class:`float` or ``None``
        :param l4_current_session_rate: The average number of l4 current sessions per second, the number is
            averaged over the last 5 one-second intervals.
        :type  l4_current_sessions: :class:`long` or ``None``
        :param l4_current_sessions: Number of l4 current sessions format: int64
        :type  l4_max_sessions: :class:`long` or ``None``
        :param l4_max_sessions: L4 max sessions is used to show the peak L4 max session data since
            load balancer starts to provide service. format: int64
        :type  l4_total_sessions: :class:`long` or ``None``
        :param l4_total_sessions: Number of l4 total sessions format: int64
        :type  l7_current_session_rate: :class:`float` or ``None``
        :param l7_current_session_rate: The average number of l7 current requests per second, the number is
            averaged over the last 5 one-second intervals.
        :type  l7_current_sessions: :class:`long` or ``None``
        :param l7_current_sessions: Number of l7 current sessions format: int64
        :type  l7_max_sessions: :class:`long` or ``None``
        :param l7_max_sessions: L7 max sessions is used to show the peak L7 max session data since
            load balancer starts to provide service. format: int64
        :type  l7_total_sessions: :class:`long` or ``None``
        :param l7_total_sessions: Number of l7 total sessions format: int64
        """
        self.l4_current_session_rate = l4_current_session_rate
        self.l4_current_sessions = l4_current_sessions
        self.l4_max_sessions = l4_max_sessions
        self.l4_total_sessions = l4_total_sessions
        self.l7_current_session_rate = l7_current_session_rate
        self.l7_current_sessions = l7_current_sessions
        self.l7_max_sessions = l7_max_sessions
        self.l7_total_sessions = l7_total_sessions
        VapiStruct.__init__(self)


LbServiceStatisticsCounter._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_service_statistics_counter', {
        'l4_current_session_rate': type.OptionalType(type.DoubleType()),
        'l4_current_sessions': type.OptionalType(type.IntegerType()),
        'l4_max_sessions': type.OptionalType(type.IntegerType()),
        'l4_total_sessions': type.OptionalType(type.IntegerType()),
        'l7_current_session_rate': type.OptionalType(type.DoubleType()),
        'l7_current_sessions': type.OptionalType(type.IntegerType()),
        'l7_max_sessions': type.OptionalType(type.IntegerType()),
        'l7_total_sessions': type.OptionalType(type.IntegerType()),
    },
    LbServiceStatisticsCounter,
    False,
    None))



class LbServiceStatus(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    SERVICE_STATUS_UP = "UP"
    """


    """
    SERVICE_STATUS_DOWN = "DOWN"
    """


    """
    SERVICE_STATUS_ERROR = "ERROR"
    """


    """
    SERVICE_STATUS_NO_STANDBY = "NO_STANDBY"
    """


    """
    SERVICE_STATUS_DETACHED = "DETACHED"
    """


    """
    SERVICE_STATUS_DISABLED = "DISABLED"
    """


    """
    SERVICE_STATUS_UNKNOWN = "UNKNOWN"
    """


    """



    _canonical_to_pep_names = {
                            'active_transport_nodes': 'active_transport_nodes',
                            'cpu_usage': 'cpu_usage',
                            'error_message': 'error_message',
                            'last_update_timestamp': 'last_update_timestamp',
                            'memory_usage': 'memory_usage',
                            'pools': 'pools',
                            'service_id': 'service_id',
                            'service_status': 'service_status',
                            'standby_transport_nodes': 'standby_transport_nodes',
                            'virtual_servers': 'virtual_servers',
                            }

    def __init__(self,
                 active_transport_nodes=None,
                 cpu_usage=None,
                 error_message=None,
                 last_update_timestamp=None,
                 memory_usage=None,
                 pools=None,
                 service_id=None,
                 service_status=None,
                 standby_transport_nodes=None,
                 virtual_servers=None,
                ):
        """
        :type  active_transport_nodes: :class:`list` of :class:`str` or ``None``
        :param active_transport_nodes: Ids of load balancer service related active transport nodes
        :type  cpu_usage: :class:`long` or ``None``
        :param cpu_usage: Cpu usage in percentage format: int64
        :type  error_message: :class:`str` or ``None``
        :param error_message: Error message, if available
        :type  last_update_timestamp: :class:`long` or ``None``
        :param last_update_timestamp: Timestamp when the data was last updated format: int64
        :type  memory_usage: :class:`long` or ``None``
        :param memory_usage: Memory usage in percentage format: int64
        :type  pools: :class:`list` of :class:`LbPoolStatus` or ``None``
        :param pools: status of load balancer pools
        :type  service_id: :class:`str` or ``None``
        :param service_id: Load balancer service identifier
        :type  service_status: :class:`str` or ``None``
        :param service_status: Possible values are: 
            
            * :attr:`LbServiceStatus.SERVICE_STATUS_UP`
            * :attr:`LbServiceStatus.SERVICE_STATUS_DOWN`
            * :attr:`LbServiceStatus.SERVICE_STATUS_ERROR`
            * :attr:`LbServiceStatus.SERVICE_STATUS_NO_STANDBY`
            * :attr:`LbServiceStatus.SERVICE_STATUS_DETACHED`
            * :attr:`LbServiceStatus.SERVICE_STATUS_DISABLED`
            * :attr:`LbServiceStatus.SERVICE_STATUS_UNKNOWN`
            
            UP means the load balancer service is working fine on both
            transport-nodes(if have); DOWN means the load balancer service is
            down on both transport-nodes (if have), hence the load balancer
            will not respond to any requests; ERROR means error happens on
            transport-node(s) or no status is reported from transport-node(s).
            The load balancer service may be working (or not working);
            NO_STANDBY means load balancer service is working in one of the
            transport node while not in the other transport-node (if have).
            Hence if the load balancer service in the working transport-node
            goes down, the load balancer service will go down; DETACHED means
            that the load balancer service has no attachment setting and is not
            instantiated in any transport nodes; DISABLED means that admin
            state of load balancer service is DISABLED; UNKNOWN means that no
            status reported from transport-nodes.The load balancer service may
            be working(or not working).
        :type  standby_transport_nodes: :class:`list` of :class:`str` or ``None``
        :param standby_transport_nodes: Ids of load balancer service related standby transport nodes
        :type  virtual_servers: :class:`list` of :class:`LbVirtualServerStatus` or ``None``
        :param virtual_servers: status of load balancer virtual servers
        """
        self.active_transport_nodes = active_transport_nodes
        self.cpu_usage = cpu_usage
        self.error_message = error_message
        self.last_update_timestamp = last_update_timestamp
        self.memory_usage = memory_usage
        self.pools = pools
        self.service_id = service_id
        self.service_status = service_status
        self.standby_transport_nodes = standby_transport_nodes
        self.virtual_servers = virtual_servers
        VapiStruct.__init__(self)


LbServiceStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_service_status', {
        'active_transport_nodes': type.OptionalType(type.ListType(type.StringType())),
        'cpu_usage': type.OptionalType(type.IntegerType()),
        'error_message': type.OptionalType(type.StringType()),
        'last_update_timestamp': type.OptionalType(type.IntegerType()),
        'memory_usage': type.OptionalType(type.IntegerType()),
        'pools': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'LbPoolStatus'))),
        'service_id': type.OptionalType(type.StringType()),
        'service_status': type.OptionalType(type.StringType()),
        'standby_transport_nodes': type.OptionalType(type.ListType(type.StringType())),
        'virtual_servers': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'LbVirtualServerStatus'))),
    },
    LbServiceStatus,
    False,
    None))



class LbServiceUsage(VapiStruct):
    """
    Describes the capacity and current usage of virtual servers, pools, pool
    members for the given load balancer service.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    SERVICE_SIZE_SMALL = "SMALL"
    """


    """
    SERVICE_SIZE_MEDIUM = "MEDIUM"
    """


    """
    SERVICE_SIZE_LARGE = "LARGE"
    """


    """
    SERVICE_SIZE_XLARGE = "XLARGE"
    """


    """
    SERVICE_SIZE_DLB = "DLB"
    """


    """
    SEVERITY_GREEN = "GREEN"
    """


    """
    SEVERITY_ORANGE = "ORANGE"
    """


    """
    SEVERITY_RED = "RED"
    """


    """



    _canonical_to_pep_names = {
                            'current_pool_count': 'current_pool_count',
                            'current_pool_member_count': 'current_pool_member_count',
                            'current_virtual_server_count': 'current_virtual_server_count',
                            'pool_capacity': 'pool_capacity',
                            'pool_member_capacity': 'pool_member_capacity',
                            'service_id': 'service_id',
                            'service_size': 'service_size',
                            'severity': 'severity',
                            'usage_percentage': 'usage_percentage',
                            'virtual_server_capacity': 'virtual_server_capacity',
                            }

    def __init__(self,
                 current_pool_count=None,
                 current_pool_member_count=None,
                 current_virtual_server_count=None,
                 pool_capacity=None,
                 pool_member_capacity=None,
                 service_id=None,
                 service_size=None,
                 severity=None,
                 usage_percentage=None,
                 virtual_server_capacity=None,
                ):
        """
        :type  current_pool_count: :class:`long` or ``None``
        :param current_pool_count: The current number of pools which have been configured in the given
            load balancer service. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  current_pool_member_count: :class:`long` or ``None``
        :param current_pool_member_count: The current number of pool members which have been configured in
            the given load balancer service. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  current_virtual_server_count: :class:`long` or ``None``
        :param current_virtual_server_count: The current number of virtual servers which have been configured in
            the given load balancer service. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  pool_capacity: :class:`long` or ``None``
        :param pool_capacity: Pool capacity means maximum number of pools which could be
            configured in the given load balancer service. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  pool_member_capacity: :class:`long` or ``None``
        :param pool_member_capacity: Pool member capacity means maximum number of pool members which
            could be configured in the given load balancer service. format:
            int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  service_id: :class:`str` or ``None``
        :param service_id: UUID of load balancer service
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  service_size: :class:`str` or ``None``
        :param service_size: Possible values are: 
            
            * :attr:`LbServiceUsage.SERVICE_SIZE_SMALL`
            * :attr:`LbServiceUsage.SERVICE_SIZE_MEDIUM`
            * :attr:`LbServiceUsage.SERVICE_SIZE_LARGE`
            * :attr:`LbServiceUsage.SERVICE_SIZE_XLARGE`
            * :attr:`LbServiceUsage.SERVICE_SIZE_DLB`
            
             The size of load balancer service
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  severity: :class:`str` or ``None``
        :param severity: Possible values are: 
            
            * :attr:`LbServiceUsage.SEVERITY_GREEN`
            * :attr:`LbServiceUsage.SEVERITY_ORANGE`
            * :attr:`LbServiceUsage.SEVERITY_RED`
            
            The severity calculation is based on the largest usage percentage
            from virtual servers, pools, pool members and rules for one load
            balancer service.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  usage_percentage: :class:`float` or ``None``
        :param usage_percentage: The usage percentage is the largest usage percentage from virtual
            servers, pools and pool members for the load balancer service. If
            the property relax_scale_validation is set as true for LbService,
            it is possible that the value is larger than 100.0. For example, if
            SMALL LBS is deployed on MEDIUM edge node and configured with
            MEDIUM LBS virtual server scale number, LBS usage percentage is
            shown larger than 100.0.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  virtual_server_capacity: :class:`long` or ``None``
        :param virtual_server_capacity: Virtual server capacity means maximum number of virtual servers
            which could be configured in the given load balancer service.
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.current_pool_count = current_pool_count
        self.current_pool_member_count = current_pool_member_count
        self.current_virtual_server_count = current_virtual_server_count
        self.pool_capacity = pool_capacity
        self.pool_member_capacity = pool_member_capacity
        self.service_id = service_id
        self.service_size = service_size
        self.severity = severity
        self.usage_percentage = usage_percentage
        self.virtual_server_capacity = virtual_server_capacity
        VapiStruct.__init__(self)


LbServiceUsage._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_service_usage', {
        'current_pool_count': type.OptionalType(type.IntegerType()),
        'current_pool_member_count': type.OptionalType(type.IntegerType()),
        'current_virtual_server_count': type.OptionalType(type.IntegerType()),
        'pool_capacity': type.OptionalType(type.IntegerType()),
        'pool_member_capacity': type.OptionalType(type.IntegerType()),
        'service_id': type.OptionalType(type.StringType()),
        'service_size': type.OptionalType(type.StringType()),
        'severity': type.OptionalType(type.StringType()),
        'usage_percentage': type.OptionalType(type.DoubleType()),
        'virtual_server_capacity': type.OptionalType(type.IntegerType()),
    },
    LbServiceUsage,
    False,
    None))



class LbSessionCookieTime(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LbSessionCookieTime"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'cookie_max_idle': 'cookie_max_idle',
                            'cookie_max_life': 'cookie_max_life',
                            'type': 'type',
                            }

    def __init__(self,
                 cookie_max_idle=None,
                 cookie_max_life=None,
                 type='LbSessionCookieTime',
                ):
        """
        :type  cookie_max_idle: :class:`long` or ``None``
        :param cookie_max_idle: Instead of using HTTP Cookie max-age and relying on client to
            expire the cookie, max idle time and/or max lifetime of the cookie
            can be used. Max idle time, if configured, specifies the maximum
            interval the cookie is valid for from the last time it was seen in
            a request. It is available for insert mode. format: int64
        :type  cookie_max_life: :class:`long` or ``None``
        :param cookie_max_life: Max life time, if configured, specifies the maximum interval the
            cookie is valid for from the first time the cookie was seen in a
            request. It is available for insert mode. format: int64
        :type  type: :class:`str`
        :param type: Possible values are: 
            
            * :attr:`LbCookieTime.TYPE_LBSESSIONCOOKIETIME`
            * :attr:`LbCookieTime.TYPE_LBPERSISTENCECOOKIETIME`
            
            Both session cookie and persistence cookie are supported, Use
            LbSessionCookieTime for session cookie time setting, Use
            LbPersistenceCookieTime for persistence cookie time setting
        """
        self.cookie_max_idle = cookie_max_idle
        self.cookie_max_life = cookie_max_life
        self._type = type
        VapiStruct.__init__(self)

    @property
    def type(self):
        """
        Return the discriminator value
        """
        return self._type

LbSessionCookieTime._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_session_cookie_time', {
        'cookie_max_idle': type.OptionalType(type.IntegerType()),
        'cookie_max_life': type.OptionalType(type.IntegerType()),
        'type': type.StringType(),
    },
    LbSessionCookieTime,
    False,
    None))



class LbSnatAutoMap(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LbSnatAutoMap"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'port_overload': 'port_overload',
                            'type': 'type',
                            }

    def __init__(self,
                 port_overload=None,
                 type='LbSnatAutoMap',
                ):
        """
        :type  port_overload: :class:`long` or ``None``
        :param port_overload: Both SNAT automap and SNAT IP list modes support port overloading
            which allows the same SNAT IP and port to be used for multiple
            backend connections as long as the tuple (source IP, source port,
            destination IP, destination port, IP protocol) after SNAT is
            performed is unique. The valid number is 1, 2, 4, 8, 16, 32. This
            is a deprecated property. The port overload factor is fixed to 32
            in load balancer engine. If it is upgraded from an old version, the
            value would be changed to 32 automatically. format: int64
        :type  type: :class:`str`
        :param type: Possible values are: 
            
            * :attr:`LbSnatTranslation.TYPE_LBSNATAUTOMAP`
            * :attr:`LbSnatTranslation.TYPE_LBSNATIPPOOL`
            
            Load balancers may need to perform SNAT to ensure reverse traffic
            from the server can be received and processed by them. There are
            two modes: LbSnatAutoMap uses the load balancer interface IP and an
            ephemeral port as the source IP and port of the server side
            connection. LbSnatIpPool allows user to specify one or more IP
            addresses along with their subnet masks that should be used for
            SNAT while connecting to any of the servers in the pool.
        """
        self.port_overload = port_overload
        self._type = type
        VapiStruct.__init__(self)

    @property
    def type(self):
        """
        Return the discriminator value
        """
        return self._type

LbSnatAutoMap._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_snat_auto_map', {
        'port_overload': type.OptionalType(type.IntegerType()),
        'type': type.StringType(),
    },
    LbSnatAutoMap,
    False,
    None))



class LbSnatIpElement(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'ip_address': 'ip_address',
                            'prefix_length': 'prefix_length',
                            }

    def __init__(self,
                 ip_address=None,
                 prefix_length=None,
                ):
        """
        :type  ip_address: :class:`str` or ``None``
        :param ip_address: Ip address or ip range such as 1.1.1.1 or 1.1.1.101-1.1.1.160
            format: address-or-block-or-range
        :type  prefix_length: :class:`long` or ``None``
        :param prefix_length: Subnet prefix length should be not specified if there is only one
            single IP address or IP range. format: int64
        """
        self.ip_address = ip_address
        self.prefix_length = prefix_length
        VapiStruct.__init__(self)


LbSnatIpElement._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_snat_ip_element', {
        'ip_address': type.OptionalType(type.StringType()),
        'prefix_length': type.OptionalType(type.IntegerType()),
    },
    LbSnatIpElement,
    False,
    None))



class LbSnatIpPool(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LbSnatIpPool"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'ip_addresses': 'ip_addresses',
                            'port_overload': 'port_overload',
                            'type': 'type',
                            }

    def __init__(self,
                 ip_addresses=None,
                 port_overload=None,
                 type='LbSnatIpPool',
                ):
        """
        :type  ip_addresses: :class:`list` of :class:`LbSnatIpElement` or ``None``
        :param ip_addresses: If an IP range is specified, the range may contain no more than 64
            IP addresses.
        :type  port_overload: :class:`long` or ``None``
        :param port_overload: Both SNAT automap and SNAT IP list modes support port overloading
            which allows the same SNAT IP and port to be used for multiple
            backend connections as long as the tuple (source IP, source port,
            destination IP, destination port, IP protocol) after SNAT is
            performed is unique. The valid number is 1, 2, 4, 8, 16, 32. This
            is a deprecated property. The port overload factor is fixed to 32
            in load balancer engine. If it is upgraded from an old version, the
            value would be changed to 32 automatically. format: int64
        :type  type: :class:`str`
        :param type: Possible values are: 
            
            * :attr:`LbSnatTranslation.TYPE_LBSNATAUTOMAP`
            * :attr:`LbSnatTranslation.TYPE_LBSNATIPPOOL`
            
            Load balancers may need to perform SNAT to ensure reverse traffic
            from the server can be received and processed by them. There are
            two modes: LbSnatAutoMap uses the load balancer interface IP and an
            ephemeral port as the source IP and port of the server side
            connection. LbSnatIpPool allows user to specify one or more IP
            addresses along with their subnet masks that should be used for
            SNAT while connecting to any of the servers in the pool.
        """
        self.ip_addresses = ip_addresses
        self.port_overload = port_overload
        self._type = type
        VapiStruct.__init__(self)

    @property
    def type(self):
        """
        Return the discriminator value
        """
        return self._type

LbSnatIpPool._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_snat_ip_pool', {
        'ip_addresses': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'LbSnatIpElement'))),
        'port_overload': type.OptionalType(type.IntegerType()),
        'type': type.StringType(),
    },
    LbSnatIpPool,
    False,
    None))



class LbSnatTranslation(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LbSnatTranslation"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    TYPE_LBSNATAUTOMAP = "LbSnatAutoMap"
    """


    """
    TYPE_LBSNATIPPOOL = "LbSnatIpPool"
    """


    """



    _canonical_to_pep_names = {
                            'port_overload': 'port_overload',
                            'type': 'type',
                            }

    def __init__(self,
                 port_overload=None,
                 type='LbSnatTranslation',
                ):
        """
        :type  port_overload: :class:`long` or ``None``
        :param port_overload: Both SNAT automap and SNAT IP list modes support port overloading
            which allows the same SNAT IP and port to be used for multiple
            backend connections as long as the tuple (source IP, source port,
            destination IP, destination port, IP protocol) after SNAT is
            performed is unique. The valid number is 1, 2, 4, 8, 16, 32. This
            is a deprecated property. The port overload factor is fixed to 32
            in load balancer engine. If it is upgraded from an old version, the
            value would be changed to 32 automatically. format: int64
        :type  type: :class:`str`
        :param type: Possible values are: 
            
            * :attr:`LbSnatTranslation.TYPE_LBSNATAUTOMAP`
            * :attr:`LbSnatTranslation.TYPE_LBSNATIPPOOL`
            
            Load balancers may need to perform SNAT to ensure reverse traffic
            from the server can be received and processed by them. There are
            two modes: LbSnatAutoMap uses the load balancer interface IP and an
            ephemeral port as the source IP and port of the server side
            connection. LbSnatIpPool allows user to specify one or more IP
            addresses along with their subnet masks that should be used for
            SNAT while connecting to any of the servers in the pool.
        """
        self.port_overload = port_overload
        self._type = type
        VapiStruct.__init__(self)

    @property
    def type(self):
        """
        Return the discriminator value
        """
        return self._type

LbSnatTranslation._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_snat_translation', {
        'port_overload': type.OptionalType(type.IntegerType()),
        'type': type.StringType(),
    },
    LbSnatTranslation,
    False,
    None))



class LbSourceIpPersistenceProfile(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LbSourceIpPersistenceProfile"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    PURGE_NO_PURGE = "NO_PURGE"
    """


    """
    PURGE_FULL = "FULL"
    """


    """



    _canonical_to_pep_names = {
                            'ha_persistence_mirroring_enabled': 'ha_persistence_mirroring_enabled',
                            'purge': 'purge',
                            'timeout': 'timeout',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'persistence_shared': 'persistence_shared',
                            }

    def __init__(self,
                 ha_persistence_mirroring_enabled=None,
                 purge=None,
                 timeout=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='LbSourceIpPersistenceProfile',
                 tags=None,
                 persistence_shared=None,
                ):
        """
        :type  ha_persistence_mirroring_enabled: :class:`bool` or ``None``
        :param ha_persistence_mirroring_enabled: Persistence entries are not synchronized to the HA peer by default.
        :type  purge: :class:`str` or ``None``
        :param purge: Possible values are: 
            
            * :attr:`LbSourceIpPersistenceProfile.PURGE_NO_PURGE`
            * :attr:`LbSourceIpPersistenceProfile.PURGE_FULL`
            
             persistence purge setting
        :type  timeout: :class:`long` or ``None``
        :param timeout: When all connections complete (reference count reaches 0),
            persistence entry timer is started with the expiration time.
            format: int64
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            *
              :attr:`LbPersistenceProfile.RESOURCE_TYPE_LBCOOKIEPERSISTENCEPROFILE`
            *
              :attr:`LbPersistenceProfile.RESOURCE_TYPE_LBSOURCEIPPERSISTENCEPROFILE`
            *
              :attr:`LbPersistenceProfile.RESOURCE_TYPE_LBGENERICPERSISTENCEPROFILE`
            
             The resource_type property identifies persistence profile type.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  persistence_shared: :class:`bool` or ``None``
        :param persistence_shared: The persistence shared flag identifies whether the persistence
            table is shared among virtual-servers referring this profile. If
            persistence shared flag is not set in the cookie persistence
            profile bound to a virtual server, it defaults to cookie
            persistence that is private to each virtual server and is qualified
            by the pool. This is accomplished by load balancer inserting a
            cookie with name in the format
            <name>.<virtual_server_id>.<pool_id>. If persistence shared flag is
            set in the cookie persistence profile, in cookie insert mode,
            cookie persistence could be shared across multiple virtual servers
            that are bound to the same pools. The cookie name would be changed
            to <name>.<profile-id>.<pool-id>. If persistence shared flag is not
            set in the sourceIp persistence profile bound to a virtual server,
            each virtual server that the profile is bound to maintains its own
            private persistence table. If persistence shared flag is set in the
            sourceIp persistence profile, all virtual servers the profile is
            bound to share the same persistence table. If persistence shared
            flag is not set in the generic persistence profile, the persistence
            entries are matched and stored in the table which is identified
            using both virtual server ID and profile ID. If persistence shared
            flag is set in the generic persistence profile, the persistence
            entries are matched and stored in the table which is identified
            using profile ID. It means that virtual servers which consume the
            same profile in the LbRule with this flag enabled are sharing the
            same persistence table.
        """
        self.ha_persistence_mirroring_enabled = ha_persistence_mirroring_enabled
        self.purge = purge
        self.timeout = timeout
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        self.persistence_shared = persistence_shared
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

LbSourceIpPersistenceProfile._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_source_ip_persistence_profile', {
        'ha_persistence_mirroring_enabled': type.OptionalType(type.BooleanType()),
        'purge': type.OptionalType(type.StringType()),
        'timeout': type.OptionalType(type.IntegerType()),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'persistence_shared': type.OptionalType(type.BooleanType()),
    },
    LbSourceIpPersistenceProfile,
    False,
    None))



class LbSslCipherAndProtocolListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'ciphers': 'ciphers',
                            'protocols': 'protocols',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 ciphers=None,
                 protocols=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  ciphers: :class:`list` of :class:`LbSslCipherInfo` or ``None``
        :param ciphers: List of SSL ciphers
        :type  protocols: :class:`list` of :class:`LbSslProtocolInfo` or ``None``
        :param protocols: List of SSL protocols
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.ciphers = ciphers
        self.protocols = protocols
        VapiStruct.__init__(self)


LbSslCipherAndProtocolListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_ssl_cipher_and_protocol_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'ciphers': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'LbSslCipherInfo'))),
        'protocols': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'LbSslProtocolInfo'))),
    },
    LbSslCipherAndProtocolListResult,
    False,
    None))



class LbSslCipherInfo(VapiStruct):
    """
    SSL cipher

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    CIPHER_ECDHE_RSA_WITH_AES_128_GCM_SHA256 = "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256"
    """


    """
    CIPHER_ECDHE_RSA_WITH_AES_256_GCM_SHA384 = "TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384"
    """


    """
    CIPHER_ECDHE_RSA_WITH_AES_256_CBC_SHA = "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA"
    """


    """
    CIPHER_ECDHE_ECDSA_WITH_AES_256_CBC_SHA = "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA"
    """


    """
    CIPHER_ECDH_ECDSA_WITH_AES_256_CBC_SHA = "TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA"
    """


    """
    CIPHER_ECDH_RSA_WITH_AES_256_CBC_SHA = "TLS_ECDH_RSA_WITH_AES_256_CBC_SHA"
    """


    """
    CIPHER_RSA_WITH_AES_256_CBC_SHA = "TLS_RSA_WITH_AES_256_CBC_SHA"
    """


    """
    CIPHER_RSA_WITH_AES_128_CBC_SHA = "TLS_RSA_WITH_AES_128_CBC_SHA"
    """


    """
    CIPHER_RSA_WITH_3DES_EDE_CBC_SHA = "TLS_RSA_WITH_3DES_EDE_CBC_SHA"
    """


    """
    CIPHER_ECDHE_RSA_WITH_AES_128_CBC_SHA = "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA"
    """


    """
    CIPHER_ECDHE_RSA_WITH_AES_128_CBC_SHA256 = "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256"
    """


    """
    CIPHER_ECDHE_RSA_WITH_AES_256_CBC_SHA384 = "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384"
    """


    """
    CIPHER_RSA_WITH_AES_128_CBC_SHA256 = "TLS_RSA_WITH_AES_128_CBC_SHA256"
    """


    """
    CIPHER_RSA_WITH_AES_128_GCM_SHA256 = "TLS_RSA_WITH_AES_128_GCM_SHA256"
    """


    """
    CIPHER_RSA_WITH_AES_256_CBC_SHA256 = "TLS_RSA_WITH_AES_256_CBC_SHA256"
    """


    """
    CIPHER_RSA_WITH_AES_256_GCM_SHA384 = "TLS_RSA_WITH_AES_256_GCM_SHA384"
    """


    """
    CIPHER_ECDHE_ECDSA_WITH_AES_128_CBC_SHA = "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA"
    """


    """
    CIPHER_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256 = "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256"
    """


    """
    CIPHER_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 = "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256"
    """


    """
    CIPHER_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384 = "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384"
    """


    """
    CIPHER_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384 = "TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384"
    """


    """
    CIPHER_ECDH_ECDSA_WITH_AES_128_CBC_SHA = "TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA"
    """


    """
    CIPHER_ECDH_ECDSA_WITH_AES_128_CBC_SHA256 = "TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256"
    """


    """
    CIPHER_ECDH_ECDSA_WITH_AES_128_GCM_SHA256 = "TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256"
    """


    """
    CIPHER_ECDH_ECDSA_WITH_AES_256_CBC_SHA384 = "TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384"
    """


    """
    CIPHER_ECDH_ECDSA_WITH_AES_256_GCM_SHA384 = "TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384"
    """


    """
    CIPHER_ECDH_RSA_WITH_AES_128_CBC_SHA = "TLS_ECDH_RSA_WITH_AES_128_CBC_SHA"
    """


    """
    CIPHER_ECDH_RSA_WITH_AES_128_CBC_SHA256 = "TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256"
    """


    """
    CIPHER_ECDH_RSA_WITH_AES_128_GCM_SHA256 = "TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256"
    """


    """
    CIPHER_ECDH_RSA_WITH_AES_256_CBC_SHA384 = "TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384"
    """


    """
    CIPHER_ECDH_RSA_WITH_AES_256_GCM_SHA384 = "TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384"
    """


    """
    CIPHER_GROUP_LABELS_BALANCED = "BALANCED"
    """


    """
    CIPHER_GROUP_LABELS_HIGH_SECURITY = "HIGH_SECURITY"
    """


    """
    CIPHER_GROUP_LABELS_HIGH_COMPATIBILITY = "HIGH_COMPATIBILITY"
    """


    """
    CIPHER_GROUP_LABELS_CUSTOM = "CUSTOM"
    """


    """



    _canonical_to_pep_names = {
                            'cipher': 'cipher',
                            'cipher_group_labels': 'cipher_group_labels',
                            'is_default': 'is_default',
                            'is_secure': 'is_secure',
                            }

    def __init__(self,
                 cipher=None,
                 cipher_group_labels=None,
                 is_default=None,
                 is_secure=None,
                ):
        """
        :type  cipher: :class:`str` or ``None``
        :param cipher: Possible values are: 
            
            * :attr:`LbSslCipherInfo.CIPHER_ECDHE_RSA_WITH_AES_128_GCM_SHA256`
            * :attr:`LbSslCipherInfo.CIPHER_ECDHE_RSA_WITH_AES_256_GCM_SHA384`
            * :attr:`LbSslCipherInfo.CIPHER_ECDHE_RSA_WITH_AES_256_CBC_SHA`
            * :attr:`LbSslCipherInfo.CIPHER_ECDHE_ECDSA_WITH_AES_256_CBC_SHA`
            * :attr:`LbSslCipherInfo.CIPHER_ECDH_ECDSA_WITH_AES_256_CBC_SHA`
            * :attr:`LbSslCipherInfo.CIPHER_ECDH_RSA_WITH_AES_256_CBC_SHA`
            * :attr:`LbSslCipherInfo.CIPHER_RSA_WITH_AES_256_CBC_SHA`
            * :attr:`LbSslCipherInfo.CIPHER_RSA_WITH_AES_128_CBC_SHA`
            * :attr:`LbSslCipherInfo.CIPHER_RSA_WITH_3DES_EDE_CBC_SHA`
            * :attr:`LbSslCipherInfo.CIPHER_ECDHE_RSA_WITH_AES_128_CBC_SHA`
            * :attr:`LbSslCipherInfo.CIPHER_ECDHE_RSA_WITH_AES_128_CBC_SHA256`
            * :attr:`LbSslCipherInfo.CIPHER_ECDHE_RSA_WITH_AES_256_CBC_SHA384`
            * :attr:`LbSslCipherInfo.CIPHER_RSA_WITH_AES_128_CBC_SHA256`
            * :attr:`LbSslCipherInfo.CIPHER_RSA_WITH_AES_128_GCM_SHA256`
            * :attr:`LbSslCipherInfo.CIPHER_RSA_WITH_AES_256_CBC_SHA256`
            * :attr:`LbSslCipherInfo.CIPHER_RSA_WITH_AES_256_GCM_SHA384`
            * :attr:`LbSslCipherInfo.CIPHER_ECDHE_ECDSA_WITH_AES_128_CBC_SHA`
            *
              :attr:`LbSslCipherInfo.CIPHER_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256`
            *
              :attr:`LbSslCipherInfo.CIPHER_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256`
            *
              :attr:`LbSslCipherInfo.CIPHER_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384`
            *
              :attr:`LbSslCipherInfo.CIPHER_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384`
            * :attr:`LbSslCipherInfo.CIPHER_ECDH_ECDSA_WITH_AES_128_CBC_SHA`
            * :attr:`LbSslCipherInfo.CIPHER_ECDH_ECDSA_WITH_AES_128_CBC_SHA256`
            * :attr:`LbSslCipherInfo.CIPHER_ECDH_ECDSA_WITH_AES_128_GCM_SHA256`
            * :attr:`LbSslCipherInfo.CIPHER_ECDH_ECDSA_WITH_AES_256_CBC_SHA384`
            * :attr:`LbSslCipherInfo.CIPHER_ECDH_ECDSA_WITH_AES_256_GCM_SHA384`
            * :attr:`LbSslCipherInfo.CIPHER_ECDH_RSA_WITH_AES_128_CBC_SHA`
            * :attr:`LbSslCipherInfo.CIPHER_ECDH_RSA_WITH_AES_128_CBC_SHA256`
            * :attr:`LbSslCipherInfo.CIPHER_ECDH_RSA_WITH_AES_128_GCM_SHA256`
            * :attr:`LbSslCipherInfo.CIPHER_ECDH_RSA_WITH_AES_256_CBC_SHA384`
            * :attr:`LbSslCipherInfo.CIPHER_ECDH_RSA_WITH_AES_256_GCM_SHA384`
            
             SSL cipher
        :type  cipher_group_labels: :class:`list` of :class:`str` or ``None``
        :param cipher_group_labels: Possible values are: 
            
            * :attr:`LbSslCipherInfo.CIPHER_GROUP_LABELS_BALANCED`
            * :attr:`LbSslCipherInfo.CIPHER_GROUP_LABELS_HIGH_SECURITY`
            * :attr:`LbSslCipherInfo.CIPHER_GROUP_LABELS_HIGH_COMPATIBILITY`
            * :attr:`LbSslCipherInfo.CIPHER_GROUP_LABELS_CUSTOM`
            
            Several cipher groups might contain the same cipher suite, each
            cipher suite could have multiple cipher group labels.
        :type  is_default: :class:`bool` or ``None``
        :param is_default: Default SSL cipher flag
        :type  is_secure: :class:`bool` or ``None``
        :param is_secure: Secure/insecure SSL cipher flag
        """
        self.cipher = cipher
        self.cipher_group_labels = cipher_group_labels
        self.is_default = is_default
        self.is_secure = is_secure
        VapiStruct.__init__(self)


LbSslCipherInfo._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_ssl_cipher_info', {
        'cipher': type.OptionalType(type.StringType()),
        'cipher_group_labels': type.OptionalType(type.ListType(type.StringType())),
        'is_default': type.OptionalType(type.BooleanType()),
        'is_secure': type.OptionalType(type.BooleanType()),
    },
    LbSslCipherInfo,
    False,
    None))



class LbSslModeSelectionAction(VapiStruct):
    """
    This action is used to select SSL mode. Three types of SSL mode actions can
    be specified in Transport phase, ssl passthrough, ssl offloading and ssl
    end-to-end.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LbSslModeSelectionAction"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    SSL_MODE_PASSTHROUGH = "SSL_PASSTHROUGH"
    """


    """
    SSL_MODE_END_TO_END = "SSL_END_TO_END"
    """


    """
    SSL_MODE_OFFLOAD = "SSL_OFFLOAD"
    """


    """



    _canonical_to_pep_names = {
                            'ssl_mode': 'ssl_mode',
                            'type': 'type',
                            }

    def __init__(self,
                 ssl_mode=None,
                 type='LbSslModeSelectionAction',
                ):
        """
        :type  ssl_mode: :class:`str` or ``None``
        :param ssl_mode: Possible values are: 
            
            * :attr:`LbSslModeSelectionAction.SSL_MODE_PASSTHROUGH`
            * :attr:`LbSslModeSelectionAction.SSL_MODE_END_TO_END`
            * :attr:`LbSslModeSelectionAction.SSL_MODE_OFFLOAD`
            
            SSL Passthrough: LB establishes a TCP connection with client and
            another connection with selected backend server. LB won't inspect
            the stream data between client and backend server, but just pass it
            through. Backend server exchanges SSL connection with client. SSL
            Offloading: LB terminiates the connections from client, and
            establishes SSL connection with it. After receiving the HTTP
            request, LB connects the selected backend server and talk with it
            via HTTP without SSL. LB estalishes new connection to selected
            backend server for each HTTP request, in case ntlm or multiplexing
            are NOT configured. SSL End-to-End: LB terminiates the connections
            from client, and establishes SSL connection with it. After
            receiving the HTTP request, LB connects the selected backend server
            and talk with it via HTTPS. LB estalishes new SSL connection to
            selected backend server for each HTTP request, in case ntlm or
            multiplexing are NOT configured.
        :type  type: :class:`str`
        :param type: Possible values are: 
            
            * :attr:`LbRuleAction.TYPE_LBHTTPREQUESTURIREWRITEACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPREQUESTHEADERREWRITEACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPREJECTACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPREDIRECTACTION`
            * :attr:`LbRuleAction.TYPE_LBSELECTPOOLACTION`
            * :attr:`LbRuleAction.TYPE_LBSELECTSERVERACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPRESPONSEHEADERREWRITEACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPREQUESTHEADERDELETEACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPRESPONSEHEADERDELETEACTION`
            * :attr:`LbRuleAction.TYPE_LBVARIABLEASSIGNMENTACTION`
            * :attr:`LbRuleAction.TYPE_LBVARIABLEPERSISTENCEONACTION`
            * :attr:`LbRuleAction.TYPE_LBVARIABLEPERSISTENCELEARNACTION`
            * :attr:`LbRuleAction.TYPE_LBJWTAUTHACTION`
            * :attr:`LbRuleAction.TYPE_LBSSLMODESELECTIONACTION`
            * :attr:`LbRuleAction.TYPE_LBCONNECTIONDROPACTION`
            
             The property identifies the load balancer rule action type.
        """
        self.ssl_mode = ssl_mode
        self._type = type
        VapiStruct.__init__(self)

    @property
    def type(self):
        """
        Return the discriminator value
        """
        return self._type

LbSslModeSelectionAction._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_ssl_mode_selection_action', {
        'ssl_mode': type.OptionalType(type.StringType()),
        'type': type.StringType(),
    },
    LbSslModeSelectionAction,
    False,
    None))



class LbSslProfile(VapiStruct):
    """
    Load balancer abstract SSL profile

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        VapiStruct.__init__(self)


LbSslProfile._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_ssl_profile', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
    },
    LbSslProfile,
    False,
    None))



class LbSslProtocolInfo(VapiStruct):
    """
    SSL protocol

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    PROTOCOL_SSL_V2 = "SSL_V2"
    """


    """
    PROTOCOL_SSL_V3 = "SSL_V3"
    """


    """
    PROTOCOL_TLS_V1 = "TLS_V1"
    """


    """
    PROTOCOL_TLS_V1_1 = "TLS_V1_1"
    """


    """
    PROTOCOL_TLS_V1_2 = "TLS_V1_2"
    """


    """



    _canonical_to_pep_names = {
                            'is_default': 'is_default',
                            'is_secure': 'is_secure',
                            'protocol': 'protocol',
                            }

    def __init__(self,
                 is_default=None,
                 is_secure=None,
                 protocol=None,
                ):
        """
        :type  is_default: :class:`bool` or ``None``
        :param is_default: Default SSL protocol flag
        :type  is_secure: :class:`bool` or ``None``
        :param is_secure: Secure/insecure SSL protocol flag
        :type  protocol: :class:`str` or ``None``
        :param protocol: Possible values are: 
            
            * :attr:`LbSslProtocolInfo.PROTOCOL_SSL_V2`
            * :attr:`LbSslProtocolInfo.PROTOCOL_SSL_V3`
            * :attr:`LbSslProtocolInfo.PROTOCOL_TLS_V1`
            * :attr:`LbSslProtocolInfo.PROTOCOL_TLS_V1_1`
            * :attr:`LbSslProtocolInfo.PROTOCOL_TLS_V1_2`
            
             SSL protocol
        """
        self.is_default = is_default
        self.is_secure = is_secure
        self.protocol = protocol
        VapiStruct.__init__(self)


LbSslProtocolInfo._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_ssl_protocol_info', {
        'is_default': type.OptionalType(type.BooleanType()),
        'is_secure': type.OptionalType(type.BooleanType()),
        'protocol': type.OptionalType(type.StringType()),
    },
    LbSslProtocolInfo,
    False,
    None))



class LbSslSniCondition(VapiStruct):
    """
    This condition is used to match SSL SNI in client hello. This condition is
    only supported in TRANSPORT phase. Only if virtual server is associated
    with client SSL profile, matching SNI condition in transport phase is
    available to be configured.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LbSslSniCondition"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    MATCH_TYPE_STARTS_WITH = "STARTS_WITH"
    """


    """
    MATCH_TYPE_ENDS_WITH = "ENDS_WITH"
    """


    """
    MATCH_TYPE_EQUALS = "EQUALS"
    """


    """
    MATCH_TYPE_CONTAINS = "CONTAINS"
    """


    """
    MATCH_TYPE_REGEX = "REGEX"
    """


    """



    _canonical_to_pep_names = {
                            'case_sensitive': 'case_sensitive',
                            'match_type': 'match_type',
                            'sni': 'sni',
                            'inverse': 'inverse',
                            'type': 'type',
                            }

    def __init__(self,
                 case_sensitive=None,
                 match_type=None,
                 sni=None,
                 inverse=None,
                 type='LbSslSniCondition',
                ):
        """
        :type  case_sensitive: :class:`bool` or ``None``
        :param case_sensitive: If true, case is significant when comparing SNI value.
        :type  match_type: :class:`str` or ``None``
        :param match_type: Possible values are: 
            
            * :attr:`LbSslSniCondition.MATCH_TYPE_STARTS_WITH`
            * :attr:`LbSslSniCondition.MATCH_TYPE_ENDS_WITH`
            * :attr:`LbSslSniCondition.MATCH_TYPE_EQUALS`
            * :attr:`LbSslSniCondition.MATCH_TYPE_CONTAINS`
            * :attr:`LbSslSniCondition.MATCH_TYPE_REGEX`
            
             Determine how a specified string value is used to match SNI.
        :type  sni: :class:`str` or ``None``
        :param sni: The SNI(Server Name indication) in client hello message.
        :type  inverse: :class:`bool` or ``None``
        :param inverse: A flag to indicate whether reverse the match result of this
            condition
        :type  type: :class:`str`
        :param type: Possible values are: 
            
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTMETHODCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTURICONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTURIARGUMENTSCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTVERSIONCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTHEADERCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTCOOKIECONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTBODYCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPRESPONSEHEADERCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBTCPHEADERCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBIPHEADERCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBVARIABLECONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPSSLCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBSSLSNICONDITION`
            
             Type of load balancer rule condition
        """
        self.case_sensitive = case_sensitive
        self.match_type = match_type
        self.sni = sni
        self.inverse = inverse
        self._type = type
        VapiStruct.__init__(self)

    @property
    def type(self):
        """
        Return the discriminator value
        """
        return self._type

LbSslSniCondition._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_ssl_sni_condition', {
        'case_sensitive': type.OptionalType(type.BooleanType()),
        'match_type': type.OptionalType(type.StringType()),
        'sni': type.OptionalType(type.StringType()),
        'inverse': type.OptionalType(type.BooleanType()),
        'type': type.StringType(),
    },
    LbSslSniCondition,
    False,
    None))



class LbStatisticsCounter(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'bytes_in': 'bytes_in',
                            'bytes_in_rate': 'bytes_in_rate',
                            'bytes_out': 'bytes_out',
                            'bytes_out_rate': 'bytes_out_rate',
                            'current_session_rate': 'current_session_rate',
                            'current_sessions': 'current_sessions',
                            'dropped_packets_by_access_list': 'dropped_packets_by_access_list',
                            'dropped_sessions_by_lbrule_action': 'dropped_sessions_by_lbrule_action',
                            'http_request_rate': 'http_request_rate',
                            'http_requests': 'http_requests',
                            'max_sessions': 'max_sessions',
                            'packets_in': 'packets_in',
                            'packets_in_rate': 'packets_in_rate',
                            'packets_out': 'packets_out',
                            'packets_out_rate': 'packets_out_rate',
                            'source_ip_persistence_entry_size': 'source_ip_persistence_entry_size',
                            'total_sessions': 'total_sessions',
                            }

    def __init__(self,
                 bytes_in=None,
                 bytes_in_rate=None,
                 bytes_out=None,
                 bytes_out_rate=None,
                 current_session_rate=None,
                 current_sessions=None,
                 dropped_packets_by_access_list=None,
                 dropped_sessions_by_lbrule_action=None,
                 http_request_rate=None,
                 http_requests=None,
                 max_sessions=None,
                 packets_in=None,
                 packets_in_rate=None,
                 packets_out=None,
                 packets_out_rate=None,
                 source_ip_persistence_entry_size=None,
                 total_sessions=None,
                ):
        """
        :type  bytes_in: :class:`long` or ``None``
        :param bytes_in: Number of bytes in format: int64
        :type  bytes_in_rate: :class:`float` or ``None``
        :param bytes_in_rate: The average number of inbound bytes per second, the number is
            averaged over the last 5 one-second intervals.
        :type  bytes_out: :class:`long` or ``None``
        :param bytes_out: Number of bytes out format: int64
        :type  bytes_out_rate: :class:`float` or ``None``
        :param bytes_out_rate: The average number of outbound bytes per second, the number is
            averaged over the last 5 one-second intervals.
        :type  current_session_rate: :class:`float` or ``None``
        :param current_session_rate: The average number of current sessions per second, the number is
            averaged over the last 5 one-second intervals.
        :type  current_sessions: :class:`long` or ``None``
        :param current_sessions: Number of current sessions format: int64
        :type  dropped_packets_by_access_list: :class:`long` or ``None``
        :param dropped_packets_by_access_list: The total number of dropped TCP SYN or UDP packets by access list
            control. format: int64
        :type  dropped_sessions_by_lbrule_action: :class:`long` or ``None``
        :param dropped_sessions_by_lbrule_action: The total number of dropped sessions by LB rule action. format:
            int64
        :type  http_request_rate: :class:`float` or ``None``
        :param http_request_rate: The average number of http requests per second, the number is
            averaged over the last 5 one-second intervals.
        :type  http_requests: :class:`long` or ``None``
        :param http_requests: The total number of http requests. format: int64
        :type  max_sessions: :class:`long` or ``None``
        :param max_sessions: Number of maximum sessions format: int64
        :type  packets_in: :class:`long` or ``None``
        :param packets_in: Number of packets in format: int64
        :type  packets_in_rate: :class:`float` or ``None``
        :param packets_in_rate: The average number of inbound packets per second, the number is
            averaged over the last 5 one-second intervals.
        :type  packets_out: :class:`long` or ``None``
        :param packets_out: Number of packets out format: int64
        :type  packets_out_rate: :class:`float` or ``None``
        :param packets_out_rate: The average number of outbound packets per second, the number is
            averaged over the last 5 one-second intervals.
        :type  source_ip_persistence_entry_size: :class:`long` or ``None``
        :param source_ip_persistence_entry_size: Number of source IP persistence entries format: int64
        :type  total_sessions: :class:`long` or ``None``
        :param total_sessions: Number of total sessions format: int64
        """
        self.bytes_in = bytes_in
        self.bytes_in_rate = bytes_in_rate
        self.bytes_out = bytes_out
        self.bytes_out_rate = bytes_out_rate
        self.current_session_rate = current_session_rate
        self.current_sessions = current_sessions
        self.dropped_packets_by_access_list = dropped_packets_by_access_list
        self.dropped_sessions_by_lbrule_action = dropped_sessions_by_lbrule_action
        self.http_request_rate = http_request_rate
        self.http_requests = http_requests
        self.max_sessions = max_sessions
        self.packets_in = packets_in
        self.packets_in_rate = packets_in_rate
        self.packets_out = packets_out
        self.packets_out_rate = packets_out_rate
        self.source_ip_persistence_entry_size = source_ip_persistence_entry_size
        self.total_sessions = total_sessions
        VapiStruct.__init__(self)


LbStatisticsCounter._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_statistics_counter', {
        'bytes_in': type.OptionalType(type.IntegerType()),
        'bytes_in_rate': type.OptionalType(type.DoubleType()),
        'bytes_out': type.OptionalType(type.IntegerType()),
        'bytes_out_rate': type.OptionalType(type.DoubleType()),
        'current_session_rate': type.OptionalType(type.DoubleType()),
        'current_sessions': type.OptionalType(type.IntegerType()),
        'dropped_packets_by_access_list': type.OptionalType(type.IntegerType()),
        'dropped_sessions_by_lbrule_action': type.OptionalType(type.IntegerType()),
        'http_request_rate': type.OptionalType(type.DoubleType()),
        'http_requests': type.OptionalType(type.IntegerType()),
        'max_sessions': type.OptionalType(type.IntegerType()),
        'packets_in': type.OptionalType(type.IntegerType()),
        'packets_in_rate': type.OptionalType(type.DoubleType()),
        'packets_out': type.OptionalType(type.IntegerType()),
        'packets_out_rate': type.OptionalType(type.DoubleType()),
        'source_ip_persistence_entry_size': type.OptionalType(type.IntegerType()),
        'total_sessions': type.OptionalType(type.IntegerType()),
    },
    LbStatisticsCounter,
    False,
    None))



class LbTcpHeaderCondition(VapiStruct):
    """
    This condition is used to match TCP header fields of HTTP messages.
    Currently, only the TCP source port is supported. Ports can be expressed as
    a single port number like 80, or a port range like 1024-1030.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LbTcpHeaderCondition"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'source_port': 'source_port',
                            'inverse': 'inverse',
                            'type': 'type',
                            }

    def __init__(self,
                 source_port=None,
                 inverse=None,
                 type='LbTcpHeaderCondition',
                ):
        """
        :type  source_port: :class:`str` or ``None``
        :param source_port: TCP source port of HTTP message format: port-or-range
        :type  inverse: :class:`bool` or ``None``
        :param inverse: A flag to indicate whether reverse the match result of this
            condition
        :type  type: :class:`str`
        :param type: Possible values are: 
            
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTMETHODCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTURICONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTURIARGUMENTSCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTVERSIONCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTHEADERCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTCOOKIECONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTBODYCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPRESPONSEHEADERCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBTCPHEADERCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBIPHEADERCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBVARIABLECONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPSSLCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBSSLSNICONDITION`
            
             Type of load balancer rule condition
        """
        self.source_port = source_port
        self.inverse = inverse
        self._type = type
        VapiStruct.__init__(self)

    @property
    def type(self):
        """
        Return the discriminator value
        """
        return self._type

LbTcpHeaderCondition._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_tcp_header_condition', {
        'source_port': type.OptionalType(type.StringType()),
        'inverse': type.OptionalType(type.BooleanType()),
        'type': type.StringType(),
    },
    LbTcpHeaderCondition,
    False,
    None))



class LbTcpMonitor(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'receive': 'receive',
                            'send': 'send',
                            'fall_count': 'fall_count',
                            'interval': 'interval',
                            'monitor_port': 'monitor_port',
                            'rise_count': 'rise_count',
                            'timeout': 'timeout',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            }

    def __init__(self,
                 receive=None,
                 send=None,
                 fall_count=None,
                 interval=None,
                 monitor_port=None,
                 rise_count=None,
                 timeout=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                ):
        """
        :type  receive: :class:`str` or ``None``
        :param receive: Expected data, if specified, can be anywhere in the response and it
            has to be a string, regular expressions are not supported.
        :type  send: :class:`str` or ``None``
        :param send: If both send and receive are not specified, then just a TCP
            connection is established (3-way handshake) to validate server is
            healthy, no data is sent.
        :type  fall_count: :class:`long` or ``None``
        :param fall_count: num of consecutive checks must fail before marking it down format:
            int64
        :type  interval: :class:`long` or ``None``
        :param interval: the frequency at which the system issues the monitor check (in
            second) format: int64
        :type  monitor_port: :class:`str` or ``None``
        :param monitor_port: If the monitor port is specified, it would override pool member
            port setting for healthcheck. A port range is not supported. For
            ICMP monitor, monitor_port is not required. format: port-or-range
        :type  rise_count: :class:`long` or ``None``
        :param rise_count: num of consecutive checks must pass before marking it up format:
            int64
        :type  timeout: :class:`long` or ``None``
        :param timeout: the number of seconds the target has in which to respond to the
            monitor request format: int64
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`LbMonitor.RESOURCE_TYPE_LBHTTPMONITOR`
            * :attr:`LbMonitor.RESOURCE_TYPE_LBHTTPSMONITOR`
            * :attr:`LbMonitor.RESOURCE_TYPE_LBICMPMONITOR`
            * :attr:`LbMonitor.RESOURCE_TYPE_LBTCPMONITOR`
            * :attr:`LbMonitor.RESOURCE_TYPE_LBUDPMONITOR`
            * :attr:`LbMonitor.RESOURCE_TYPE_LBPASSIVEMONITOR`
            
            Load balancers monitor the health of backend servers to ensure
            traffic is not black holed. There are two types of healthchecks:
            active and passive. Passive healthchecks depend on failures in
            actual client traffic (e.g. RST from server in response to a client
            connection) to detect that the server or the application is down.
            In case of active healthchecks, load balancer itself initiates new
            connections (or sends ICMP ping) to the servers periodically to
            check their health, completely independent of any data traffic.
            Currently, active health monitors are supported for HTTP, HTTPS,
            TCP, UDP and ICMP protocols.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        """
        self.receive = receive
        self.send = send
        self.fall_count = fall_count
        self.interval = interval
        self.monitor_port = monitor_port
        self.rise_count = rise_count
        self.timeout = timeout
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

LbTcpMonitor._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_tcp_monitor', {
        'receive': type.OptionalType(type.StringType()),
        'send': type.OptionalType(type.StringType()),
        'fall_count': type.OptionalType(type.IntegerType()),
        'interval': type.OptionalType(type.IntegerType()),
        'monitor_port': type.OptionalType(type.StringType()),
        'rise_count': type.OptionalType(type.IntegerType()),
        'timeout': type.OptionalType(type.IntegerType()),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
    },
    LbTcpMonitor,
    False,
    None))



class LbTcpProfile(VapiStruct):
    """
    TCP profile allows customization of TCP stack behavior for each
    application. As TCP connections are terminated (or initiated) on the load
    balancer only for L7 virtual servers, TCP profiles are applicable only to
    them. As the desired TCP characteristics (e.g. Rx/Tx buffers) may be
    different for client (typically on WAN) and server (typically on LAN)
    sides, two separate profiles can be bound to virtual server, one for
    client-side (LbVirtualServer.client_tcp_profile_id) and another for
    server-side (LbVirtualServer.server_tcp_profile_id).

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'fin_wait2_timeout': 'fin_wait2_timeout',
                            'max_syn_retransmissions': 'max_syn_retransmissions',
                            'nagle_algorithm_enabled': 'nagle_algorithm_enabled',
                            'receive_window_size': 'receive_window_size',
                            'transmit_window_size': 'transmit_window_size',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 fin_wait2_timeout=None,
                 max_syn_retransmissions=None,
                 nagle_algorithm_enabled=None,
                 receive_window_size=None,
                 transmit_window_size=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  fin_wait2_timeout: :class:`long` or ``None``
        :param fin_wait2_timeout: If the field is not specified, the load balancer will use the
            default setting per load balancer service flavor. format: int64
        :type  max_syn_retransmissions: :class:`long` or ``None``
        :param max_syn_retransmissions: If the field is not specified, the load balancer will use the
            default setting per load balancer service flavor. format: int64
        :type  nagle_algorithm_enabled: :class:`bool` or ``None``
        :param nagle_algorithm_enabled: Setting this option to enable or disable Nagle's algorithm.
        :type  receive_window_size: :class:`long` or ``None``
        :param receive_window_size: If the field is not specified, the load balancer will use the
            default setting per load balancer service flavor. format: int64
        :type  transmit_window_size: :class:`long` or ``None``
        :param transmit_window_size: If the field is not specified, the load balancer will use the
            default setting per load balancer service flavor. format: int64
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.fin_wait2_timeout = fin_wait2_timeout
        self.max_syn_retransmissions = max_syn_retransmissions
        self.nagle_algorithm_enabled = nagle_algorithm_enabled
        self.receive_window_size = receive_window_size
        self.transmit_window_size = transmit_window_size
        VapiStruct.__init__(self)


LbTcpProfile._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_tcp_profile', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'fin_wait2_timeout': type.OptionalType(type.IntegerType()),
        'max_syn_retransmissions': type.OptionalType(type.IntegerType()),
        'nagle_algorithm_enabled': type.OptionalType(type.BooleanType()),
        'receive_window_size': type.OptionalType(type.IntegerType()),
        'transmit_window_size': type.OptionalType(type.IntegerType()),
    },
    LbTcpProfile,
    False,
    None))



class LbTcpProfileListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`LbTcpProfile` or ``None``
        :param results: Paginated list of load balancer TCP profiles
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


LbTcpProfileListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_tcp_profile_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'LbTcpProfile'))),
    },
    LbTcpProfileListResult,
    False,
    None))



class LbUdpMonitor(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'receive': 'receive',
                            'send': 'send',
                            'fall_count': 'fall_count',
                            'interval': 'interval',
                            'monitor_port': 'monitor_port',
                            'rise_count': 'rise_count',
                            'timeout': 'timeout',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            }

    def __init__(self,
                 receive=None,
                 send=None,
                 fall_count=None,
                 interval=None,
                 monitor_port=None,
                 rise_count=None,
                 timeout=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                ):
        """
        :type  receive: :class:`str` or ``None``
        :param receive: Expected data, can be anywhere in the response and it has to be a
            string, regular expressions are not supported. UDP healthcheck is
            considered failed if there is no server response within the timeout
            period.
        :type  send: :class:`str` or ``None``
        :param send: The data to be sent to the monitored server.
        :type  fall_count: :class:`long` or ``None``
        :param fall_count: num of consecutive checks must fail before marking it down format:
            int64
        :type  interval: :class:`long` or ``None``
        :param interval: the frequency at which the system issues the monitor check (in
            second) format: int64
        :type  monitor_port: :class:`str` or ``None``
        :param monitor_port: If the monitor port is specified, it would override pool member
            port setting for healthcheck. A port range is not supported. For
            ICMP monitor, monitor_port is not required. format: port-or-range
        :type  rise_count: :class:`long` or ``None``
        :param rise_count: num of consecutive checks must pass before marking it up format:
            int64
        :type  timeout: :class:`long` or ``None``
        :param timeout: the number of seconds the target has in which to respond to the
            monitor request format: int64
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`LbMonitor.RESOURCE_TYPE_LBHTTPMONITOR`
            * :attr:`LbMonitor.RESOURCE_TYPE_LBHTTPSMONITOR`
            * :attr:`LbMonitor.RESOURCE_TYPE_LBICMPMONITOR`
            * :attr:`LbMonitor.RESOURCE_TYPE_LBTCPMONITOR`
            * :attr:`LbMonitor.RESOURCE_TYPE_LBUDPMONITOR`
            * :attr:`LbMonitor.RESOURCE_TYPE_LBPASSIVEMONITOR`
            
            Load balancers monitor the health of backend servers to ensure
            traffic is not black holed. There are two types of healthchecks:
            active and passive. Passive healthchecks depend on failures in
            actual client traffic (e.g. RST from server in response to a client
            connection) to detect that the server or the application is down.
            In case of active healthchecks, load balancer itself initiates new
            connections (or sends ICMP ping) to the servers periodically to
            check their health, completely independent of any data traffic.
            Currently, active health monitors are supported for HTTP, HTTPS,
            TCP, UDP and ICMP protocols.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        """
        self.receive = receive
        self.send = send
        self.fall_count = fall_count
        self.interval = interval
        self.monitor_port = monitor_port
        self.rise_count = rise_count
        self.timeout = timeout
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

LbUdpMonitor._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_udp_monitor', {
        'receive': type.OptionalType(type.StringType()),
        'send': type.OptionalType(type.StringType()),
        'fall_count': type.OptionalType(type.IntegerType()),
        'interval': type.OptionalType(type.IntegerType()),
        'monitor_port': type.OptionalType(type.StringType()),
        'rise_count': type.OptionalType(type.IntegerType()),
        'timeout': type.OptionalType(type.IntegerType()),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
    },
    LbUdpMonitor,
    False,
    None))



class LbVariableAssignmentAction(VapiStruct):
    """
    This action is used to create a new variable and assign value to it. One
    action can be used to create one variable. To create multiple variables,
    multiple actions must be defined. The variables can be used by
    LbVariableCondition, etc.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LbVariableAssignmentAction"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'variable_name': 'variable_name',
                            'variable_value': 'variable_value',
                            'type': 'type',
                            }

    def __init__(self,
                 variable_name=None,
                 variable_value=None,
                 type='LbVariableAssignmentAction',
                ):
        """
        :type  variable_name: :class:`str` or ``None``
        :param variable_name: Name of the variable to be assigned
        :type  variable_value: :class:`str` or ``None``
        :param variable_value: Value of variable
        :type  type: :class:`str`
        :param type: Possible values are: 
            
            * :attr:`LbRuleAction.TYPE_LBHTTPREQUESTURIREWRITEACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPREQUESTHEADERREWRITEACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPREJECTACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPREDIRECTACTION`
            * :attr:`LbRuleAction.TYPE_LBSELECTPOOLACTION`
            * :attr:`LbRuleAction.TYPE_LBSELECTSERVERACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPRESPONSEHEADERREWRITEACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPREQUESTHEADERDELETEACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPRESPONSEHEADERDELETEACTION`
            * :attr:`LbRuleAction.TYPE_LBVARIABLEASSIGNMENTACTION`
            * :attr:`LbRuleAction.TYPE_LBVARIABLEPERSISTENCEONACTION`
            * :attr:`LbRuleAction.TYPE_LBVARIABLEPERSISTENCELEARNACTION`
            * :attr:`LbRuleAction.TYPE_LBJWTAUTHACTION`
            * :attr:`LbRuleAction.TYPE_LBSSLMODESELECTIONACTION`
            * :attr:`LbRuleAction.TYPE_LBCONNECTIONDROPACTION`
            
             The property identifies the load balancer rule action type.
        """
        self.variable_name = variable_name
        self.variable_value = variable_value
        self._type = type
        VapiStruct.__init__(self)

    @property
    def type(self):
        """
        Return the discriminator value
        """
        return self._type

LbVariableAssignmentAction._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_variable_assignment_action', {
        'variable_name': type.OptionalType(type.StringType()),
        'variable_value': type.OptionalType(type.StringType()),
        'type': type.StringType(),
    },
    LbVariableAssignmentAction,
    False,
    None))



class LbVariableCondition(VapiStruct):
    """
    This condition is used to match variable's name and value at all phases.
    The variables could be captured from REGEX or assigned by
    LbVariableAssignmentAction or system embedded variable. Varialbe_name and
    variable_value should be matched at the same time.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LbVariableCondition"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    MATCH_TYPE_STARTS_WITH = "STARTS_WITH"
    """


    """
    MATCH_TYPE_ENDS_WITH = "ENDS_WITH"
    """


    """
    MATCH_TYPE_EQUALS = "EQUALS"
    """


    """
    MATCH_TYPE_CONTAINS = "CONTAINS"
    """


    """
    MATCH_TYPE_REGEX = "REGEX"
    """


    """



    _canonical_to_pep_names = {
                            'case_sensitive': 'case_sensitive',
                            'match_type': 'match_type',
                            'variable_name': 'variable_name',
                            'variable_value': 'variable_value',
                            'inverse': 'inverse',
                            'type': 'type',
                            }

    def __init__(self,
                 case_sensitive=None,
                 match_type=None,
                 variable_name=None,
                 variable_value=None,
                 inverse=None,
                 type='LbVariableCondition',
                ):
        """
        :type  case_sensitive: :class:`bool` or ``None``
        :param case_sensitive: If true, case is significant when comparing variable value.
        :type  match_type: :class:`str` or ``None``
        :param match_type: Possible values are: 
            
            * :attr:`LbVariableCondition.MATCH_TYPE_STARTS_WITH`
            * :attr:`LbVariableCondition.MATCH_TYPE_ENDS_WITH`
            * :attr:`LbVariableCondition.MATCH_TYPE_EQUALS`
            * :attr:`LbVariableCondition.MATCH_TYPE_CONTAINS`
            * :attr:`LbVariableCondition.MATCH_TYPE_REGEX`
            
             Match type of variable value
        :type  variable_name: :class:`str` or ``None``
        :param variable_name: Name of the variable to be matched
        :type  variable_value: :class:`str` or ``None``
        :param variable_value: Value of variable to be matched
        :type  inverse: :class:`bool` or ``None``
        :param inverse: A flag to indicate whether reverse the match result of this
            condition
        :type  type: :class:`str`
        :param type: Possible values are: 
            
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTMETHODCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTURICONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTURIARGUMENTSCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTVERSIONCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTHEADERCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTCOOKIECONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPREQUESTBODYCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPRESPONSEHEADERCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBTCPHEADERCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBIPHEADERCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBVARIABLECONDITION`
            * :attr:`LbRuleCondition.TYPE_LBHTTPSSLCONDITION`
            * :attr:`LbRuleCondition.TYPE_LBSSLSNICONDITION`
            
             Type of load balancer rule condition
        """
        self.case_sensitive = case_sensitive
        self.match_type = match_type
        self.variable_name = variable_name
        self.variable_value = variable_value
        self.inverse = inverse
        self._type = type
        VapiStruct.__init__(self)

    @property
    def type(self):
        """
        Return the discriminator value
        """
        return self._type

LbVariableCondition._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_variable_condition', {
        'case_sensitive': type.OptionalType(type.BooleanType()),
        'match_type': type.OptionalType(type.StringType()),
        'variable_name': type.OptionalType(type.StringType()),
        'variable_value': type.OptionalType(type.StringType()),
        'inverse': type.OptionalType(type.BooleanType()),
        'type': type.StringType(),
    },
    LbVariableCondition,
    False,
    None))



class LbVariablePersistenceLearnAction(VapiStruct):
    """
    This action is performed in HTTP response rewrite phase. It is used to
    learn the value of variable from the HTTP response, and insert an entry
    into the persistence table if the entry doesn't exist.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LbVariablePersistenceLearnAction"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'persistence_profile_id': 'persistence_profile_id',
                            'variable_hash_enabled': 'variable_hash_enabled',
                            'variable_name': 'variable_name',
                            'type': 'type',
                            }

    def __init__(self,
                 persistence_profile_id=None,
                 variable_hash_enabled=None,
                 variable_name=None,
                 type='LbVariablePersistenceLearnAction',
                ):
        """
        :type  persistence_profile_id: :class:`str` or ``None``
        :param persistence_profile_id: If the persistence profile UUID is not specified, a default
            persistence table is created per virtual server. Currently, only
            LbGenericPersistenceProfile is supported.
        :type  variable_hash_enabled: :class:`bool` or ``None``
        :param variable_hash_enabled: The property is used to enable a hash operation for variable value
            when composing the persistence key.
        :type  variable_name: :class:`str` or ``None``
        :param variable_name: The property is the name of variable to be learnt. It is used to
            identify which variable's value is learnt from HTTP response. The
            variable can be a system embedded variable such as
            \"_cookie_JSESSIONID\", a customized variable defined in
            LbVariableAssignmentAction or a captured variable in regular
            expression such as \"article\".
        :type  type: :class:`str`
        :param type: Possible values are: 
            
            * :attr:`LbRuleAction.TYPE_LBHTTPREQUESTURIREWRITEACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPREQUESTHEADERREWRITEACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPREJECTACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPREDIRECTACTION`
            * :attr:`LbRuleAction.TYPE_LBSELECTPOOLACTION`
            * :attr:`LbRuleAction.TYPE_LBSELECTSERVERACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPRESPONSEHEADERREWRITEACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPREQUESTHEADERDELETEACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPRESPONSEHEADERDELETEACTION`
            * :attr:`LbRuleAction.TYPE_LBVARIABLEASSIGNMENTACTION`
            * :attr:`LbRuleAction.TYPE_LBVARIABLEPERSISTENCEONACTION`
            * :attr:`LbRuleAction.TYPE_LBVARIABLEPERSISTENCELEARNACTION`
            * :attr:`LbRuleAction.TYPE_LBJWTAUTHACTION`
            * :attr:`LbRuleAction.TYPE_LBSSLMODESELECTIONACTION`
            * :attr:`LbRuleAction.TYPE_LBCONNECTIONDROPACTION`
            
             The property identifies the load balancer rule action type.
        """
        self.persistence_profile_id = persistence_profile_id
        self.variable_hash_enabled = variable_hash_enabled
        self.variable_name = variable_name
        self._type = type
        VapiStruct.__init__(self)

    @property
    def type(self):
        """
        Return the discriminator value
        """
        return self._type

LbVariablePersistenceLearnAction._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_variable_persistence_learn_action', {
        'persistence_profile_id': type.OptionalType(type.StringType()),
        'variable_hash_enabled': type.OptionalType(type.BooleanType()),
        'variable_name': type.OptionalType(type.StringType()),
        'type': type.StringType(),
    },
    LbVariablePersistenceLearnAction,
    False,
    None))



class LbVariablePersistenceOnAction(VapiStruct):
    """
    This action is performed in HTTP forwarding phase. It is used to inspect
    the variable of HTTP request, and look up the persistence entry with its
    value and pool uuid as key. If the persistence entry is found, the HTTP
    request is forwarded to the recorded backend server according to the
    persistence entry. If the persistence entry is not found, a new entry is
    created in the table after backend server is selected.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LbVariablePersistenceOnAction"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'persistence_profile_id': 'persistence_profile_id',
                            'variable_hash_enabled': 'variable_hash_enabled',
                            'variable_name': 'variable_name',
                            'type': 'type',
                            }

    def __init__(self,
                 persistence_profile_id=None,
                 variable_hash_enabled=None,
                 variable_name=None,
                 type='LbVariablePersistenceOnAction',
                ):
        """
        :type  persistence_profile_id: :class:`str` or ``None``
        :param persistence_profile_id: If the persistence profile UUID is not specified, a default
            persistence table is created per virtual server. Currently, only
            LbGenericPersistenceProfile is supported.
        :type  variable_hash_enabled: :class:`bool` or ``None``
        :param variable_hash_enabled: The property is used to enable a hash operation for variable value
            when composing the persistence key.
        :type  variable_name: :class:`str` or ``None``
        :param variable_name: The property is the name of variable to be used. It specifies which
            variable's value of a HTTP Request will be used in the key of
            persistence entry. The variable can be a system embedded variable
            such as \"_cookie_JSESSIONID\", a customized variable defined in
            LbVariableAssignmentAction or a captured variable in regular
            expression such as \"article\".
        :type  type: :class:`str`
        :param type: Possible values are: 
            
            * :attr:`LbRuleAction.TYPE_LBHTTPREQUESTURIREWRITEACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPREQUESTHEADERREWRITEACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPREJECTACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPREDIRECTACTION`
            * :attr:`LbRuleAction.TYPE_LBSELECTPOOLACTION`
            * :attr:`LbRuleAction.TYPE_LBSELECTSERVERACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPRESPONSEHEADERREWRITEACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPREQUESTHEADERDELETEACTION`
            * :attr:`LbRuleAction.TYPE_LBHTTPRESPONSEHEADERDELETEACTION`
            * :attr:`LbRuleAction.TYPE_LBVARIABLEASSIGNMENTACTION`
            * :attr:`LbRuleAction.TYPE_LBVARIABLEPERSISTENCEONACTION`
            * :attr:`LbRuleAction.TYPE_LBVARIABLEPERSISTENCELEARNACTION`
            * :attr:`LbRuleAction.TYPE_LBJWTAUTHACTION`
            * :attr:`LbRuleAction.TYPE_LBSSLMODESELECTIONACTION`
            * :attr:`LbRuleAction.TYPE_LBCONNECTIONDROPACTION`
            
             The property identifies the load balancer rule action type.
        """
        self.persistence_profile_id = persistence_profile_id
        self.variable_hash_enabled = variable_hash_enabled
        self.variable_name = variable_name
        self._type = type
        VapiStruct.__init__(self)

    @property
    def type(self):
        """
        Return the discriminator value
        """
        return self._type

LbVariablePersistenceOnAction._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_variable_persistence_on_action', {
        'persistence_profile_id': type.OptionalType(type.StringType()),
        'variable_hash_enabled': type.OptionalType(type.BooleanType()),
        'variable_name': type.OptionalType(type.StringType()),
        'type': type.StringType(),
    },
    LbVariablePersistenceOnAction,
    False,
    None))



class LbVirtualServer(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    IP_PROTOCOL_TCP = "TCP"
    """


    """
    IP_PROTOCOL_UDP = "UDP"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'access_list_control': 'access_list_control',
                            'access_log_enabled': 'access_log_enabled',
                            'application_profile_id': 'application_profile_id',
                            'client_ssl_profile_binding': 'client_ssl_profile_binding',
                            'client_tcp_profile_id': 'client_tcp_profile_id',
                            'default_pool_member_port': 'default_pool_member_port',
                            'default_pool_member_ports': 'default_pool_member_ports',
                            'enabled': 'enabled',
                            'ip_address': 'ip_address',
                            'ip_protocol': 'ip_protocol',
                            'log_significant_event_only': 'log_significant_event_only',
                            'max_concurrent_connections': 'max_concurrent_connections',
                            'max_new_connection_rate': 'max_new_connection_rate',
                            'persistence_profile_id': 'persistence_profile_id',
                            'pool_id': 'pool_id',
                            'port': 'port',
                            'ports': 'ports',
                            'rule_ids': 'rule_ids',
                            'server_ssl_profile_binding': 'server_ssl_profile_binding',
                            'server_tcp_profile_id': 'server_tcp_profile_id',
                            'sorry_pool_id': 'sorry_pool_id',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 access_list_control=None,
                 access_log_enabled=None,
                 application_profile_id=None,
                 client_ssl_profile_binding=None,
                 client_tcp_profile_id=None,
                 default_pool_member_port=None,
                 default_pool_member_ports=None,
                 enabled=None,
                 ip_address=None,
                 ip_protocol=None,
                 log_significant_event_only=None,
                 max_concurrent_connections=None,
                 max_new_connection_rate=None,
                 persistence_profile_id=None,
                 pool_id=None,
                 port=None,
                 ports=None,
                 rule_ids=None,
                 server_ssl_profile_binding=None,
                 server_tcp_profile_id=None,
                 sorry_pool_id=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  access_list_control: :class:`LbAccessListControl` or ``None``
        :param access_list_control: Specifies the access list control to define how to filter the
            connections from clients.
        :type  access_log_enabled: :class:`bool` or ``None``
        :param access_log_enabled: Whether access log is enabled
        :type  application_profile_id: :class:`str` or ``None``
        :param application_profile_id: The application profile defines the application protocol
            characteristics. It is used to influence how load balancing is
            performed. Currently, LbFastTCPProfile, LbFastUDPProfile and
            LbHttpProfile, etc are supported.
        :type  client_ssl_profile_binding: :class:`ClientSslProfileBinding` or ``None``
        :param client_ssl_profile_binding: The setting is used when load balancer acts as an SSL server and
            terminating the client SSL connection
        :type  client_tcp_profile_id: :class:`str` or ``None``
        :param client_tcp_profile_id: Only L7 virtual server could be configured with customized client
            side TCP profile.
        :type  default_pool_member_port: :class:`str` or ``None``
        :param default_pool_member_port: This is a deprecated property, please use
            'default_pool_member_ports' instead. If default_pool_member_port is
            configured and default_pool_member_ports are not specified, both
            default_pool_member_port and default_pool_member_ports in response
            payload would return the same port value. If both are specified,
            default_pool_member_ports setting would take effect with higher
            priority. format: port-or-range
        :type  default_pool_member_ports: :class:`list` of :class:`str` or ``None``
        :param default_pool_member_ports: If default_pool_member_ports are configured, both
            default_pool_member_port and default_pool_member_ports in the
            response payload would include port settings, notice that the value
            of default_pool_member_port is the first element of
            default_pool_member_ports. format: port-or-range
        :type  enabled: :class:`bool` or ``None``
        :param enabled: whether the virtual server is enabled
        :type  ip_address: :class:`str` or ``None``
        :param ip_address: virtual server IP address format: ip
        :type  ip_protocol: :class:`str` or ``None``
        :param ip_protocol: Possible values are: 
            
            * :attr:`LbVirtualServer.IP_PROTOCOL_TCP`
            * :attr:`LbVirtualServer.IP_PROTOCOL_UDP`
            
             Assigned Internet Protocol in IP header, TCP, UDP are supported.
        :type  log_significant_event_only: :class:`bool` or ``None``
        :param log_significant_event_only: The property log_significant_event_only can take effect only when
            access_log_enabled is true. If log_significant_event_only is true,
            significant events are logged in access log. For L4 virtual server,
            significant event means unsuccessful(error or dropped) TCP/UDP
            connections. For L7 virtual server, significant event means
            unsuccessful connections or HTTP/HTTPS requests which have error
            response code(e.g. 4xx, 5xx).
        :type  max_concurrent_connections: :class:`long` or ``None``
        :param max_concurrent_connections: To ensure one virtual server does not over consume resources,
            affecting other applications hosted on the same LBS, connections to
            a virtual server can be capped. If it is not specified, it means
            that connections are unlimited. format: int64
        :type  max_new_connection_rate: :class:`long` or ``None``
        :param max_new_connection_rate: To ensure one virtual server does not over consume resources,
            connections to a member can be rate limited. If it is not
            specified, it means that connection rate is unlimited. format:
            int64
        :type  persistence_profile_id: :class:`str` or ``None``
        :param persistence_profile_id: Persistence profile is used to allow related client connections to
            be sent to the same backend server.
        :type  pool_id: :class:`str` or ``None``
        :param pool_id: The server pool(LbPool) contains backend servers. Server pool
            consists of one or more servers, also referred to as pool members,
            that are similarly configured and are running the same application.
        :type  port: :class:`str` or ``None``
        :param port: This is a deprecated property, please use 'ports' instead. Port
            setting could be single port for both L7 mode and L4 mode. For L4
            mode, a single port range is also supported. The port setting could
            be a single port or port range such as \"80\", \"1234-1236\". If
            port is configured and ports are not specified, both port and ports
            in response payload would return the same port value. If both port
            and ports are configured, ports setting would take effect with
            higher priority. format: port-or-range
        :type  ports: :class:`list` of :class:`str` or ``None``
        :param ports: Port setting could be a single port for both L7 mode and L4 mode.
            For L4 mode, multiple ports or port ranges are also supported such
            as \"80\", \"443\", \"1234-1236\". If ports is configured, both
            port and ports in the response payload would include port settings,
            notice that the port field value is the first element of ports.
            format: port-or-range
        :type  rule_ids: :class:`list` of :class:`str` or ``None``
        :param rule_ids: Load balancer rules allow customization of load balancing behavior
            using match/action rules. Currently, load balancer rules are
            supported for only layer 7 virtual servers with LbHttpProfile.
        :type  server_ssl_profile_binding: :class:`ServerSslProfileBinding` or ``None``
        :param server_ssl_profile_binding: The setting is used when load balancer acts as an SSL client and
            establishing a connection to the backend server.
        :type  server_tcp_profile_id: :class:`str` or ``None``
        :param server_tcp_profile_id: Only L7 virtual server could be configured with customized server
            side TCP profile.
        :type  sorry_pool_id: :class:`str` or ``None``
        :param sorry_pool_id: When load balancer can not select a backend server to serve the
            request in default pool or pool in rules, the request would be
            served by sorry server pool.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.access_list_control = access_list_control
        self.access_log_enabled = access_log_enabled
        self.application_profile_id = application_profile_id
        self.client_ssl_profile_binding = client_ssl_profile_binding
        self.client_tcp_profile_id = client_tcp_profile_id
        self.default_pool_member_port = default_pool_member_port
        self.default_pool_member_ports = default_pool_member_ports
        self.enabled = enabled
        self.ip_address = ip_address
        self.ip_protocol = ip_protocol
        self.log_significant_event_only = log_significant_event_only
        self.max_concurrent_connections = max_concurrent_connections
        self.max_new_connection_rate = max_new_connection_rate
        self.persistence_profile_id = persistence_profile_id
        self.pool_id = pool_id
        self.port = port
        self.ports = ports
        self.rule_ids = rule_ids
        self.server_ssl_profile_binding = server_ssl_profile_binding
        self.server_tcp_profile_id = server_tcp_profile_id
        self.sorry_pool_id = sorry_pool_id
        VapiStruct.__init__(self)


LbVirtualServer._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_virtual_server', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'access_list_control': type.OptionalType(type.ReferenceType(__name__, 'LbAccessListControl')),
        'access_log_enabled': type.OptionalType(type.BooleanType()),
        'application_profile_id': type.OptionalType(type.StringType()),
        'client_ssl_profile_binding': type.OptionalType(type.ReferenceType(__name__, 'ClientSslProfileBinding')),
        'client_tcp_profile_id': type.OptionalType(type.StringType()),
        'default_pool_member_port': type.OptionalType(type.StringType()),
        'default_pool_member_ports': type.OptionalType(type.ListType(type.StringType())),
        'enabled': type.OptionalType(type.BooleanType()),
        'ip_address': type.OptionalType(type.StringType()),
        'ip_protocol': type.OptionalType(type.StringType()),
        'log_significant_event_only': type.OptionalType(type.BooleanType()),
        'max_concurrent_connections': type.OptionalType(type.IntegerType()),
        'max_new_connection_rate': type.OptionalType(type.IntegerType()),
        'persistence_profile_id': type.OptionalType(type.StringType()),
        'pool_id': type.OptionalType(type.StringType()),
        'port': type.OptionalType(type.StringType()),
        'ports': type.OptionalType(type.ListType(type.StringType())),
        'rule_ids': type.OptionalType(type.ListType(type.StringType())),
        'server_ssl_profile_binding': type.OptionalType(type.ReferenceType(__name__, 'ServerSslProfileBinding')),
        'server_tcp_profile_id': type.OptionalType(type.StringType()),
        'sorry_pool_id': type.OptionalType(type.StringType()),
    },
    LbVirtualServer,
    False,
    None))



class LbVirtualServerListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`LbVirtualServer` or ``None``
        :param results: paginated list of virtual servers
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


LbVirtualServerListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_virtual_server_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'LbVirtualServer'))),
    },
    LbVirtualServerListResult,
    False,
    None))



class LbVirtualServerStatistics(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'last_update_timestamp': 'last_update_timestamp',
                            'statistics': 'statistics',
                            'virtual_server_id': 'virtual_server_id',
                            }

    def __init__(self,
                 last_update_timestamp=None,
                 statistics=None,
                 virtual_server_id=None,
                ):
        """
        :type  last_update_timestamp: :class:`long` or ``None``
        :param last_update_timestamp: Timestamp when the data was last updated format: int64
        :type  statistics: :class:`LbStatisticsCounter` or ``None``
        :param statistics: Virtual server statistics counter
        :type  virtual_server_id: :class:`str` or ``None``
        :param virtual_server_id: load balancer virtual server identifier
        """
        self.last_update_timestamp = last_update_timestamp
        self.statistics = statistics
        self.virtual_server_id = virtual_server_id
        VapiStruct.__init__(self)


LbVirtualServerStatistics._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_virtual_server_statistics', {
        'last_update_timestamp': type.OptionalType(type.IntegerType()),
        'statistics': type.OptionalType(type.ReferenceType(__name__, 'LbStatisticsCounter')),
        'virtual_server_id': type.OptionalType(type.StringType()),
    },
    LbVirtualServerStatistics,
    False,
    None))



class LbVirtualServerStatisticsListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`LbVirtualServerStatistics` or ``None``
        :param results: paginated statistics list of virtual servers
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


LbVirtualServerStatisticsListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_virtual_server_statistics_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'LbVirtualServerStatistics'))),
    },
    LbVirtualServerStatisticsListResult,
    False,
    None))



class LbVirtualServerStatus(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATUS_UP = "UP"
    """


    """
    STATUS_PARTIALLY_UP = "PARTIALLY_UP"
    """


    """
    STATUS_PRIMARY_DOWN = "PRIMARY_DOWN"
    """


    """
    STATUS_DOWN = "DOWN"
    """


    """
    STATUS_DETACHED = "DETACHED"
    """


    """
    STATUS_DISABLED = "DISABLED"
    """


    """
    STATUS_UNKNOWN = "UNKNOWN"
    """


    """



    _canonical_to_pep_names = {
                            'last_update_timestamp': 'last_update_timestamp',
                            'status': 'status',
                            'virtual_server_id': 'virtual_server_id',
                            }

    def __init__(self,
                 last_update_timestamp=None,
                 status=None,
                 virtual_server_id=None,
                ):
        """
        :type  last_update_timestamp: :class:`long` or ``None``
        :param last_update_timestamp: Timestamp when the data was last updated. format: int64
        :type  status: :class:`str` or ``None``
        :param status: Possible values are: 
            
            * :attr:`LbVirtualServerStatus.STATUS_UP`
            * :attr:`LbVirtualServerStatus.STATUS_PARTIALLY_UP`
            * :attr:`LbVirtualServerStatus.STATUS_PRIMARY_DOWN`
            * :attr:`LbVirtualServerStatus.STATUS_DOWN`
            * :attr:`LbVirtualServerStatus.STATUS_DETACHED`
            * :attr:`LbVirtualServerStatus.STATUS_DISABLED`
            * :attr:`LbVirtualServerStatus.STATUS_UNKNOWN`
            
            UP means that all primary members in default pool are in UP status.
            For L7 virtual server, if there is no default pool, the virtual
            server would be treated as UP. PARTIALLY_UP means that some(not
            all) primary members in default pool are in UP status. The size of
            these active primary members should be larger than or equal to the
            certain number(min_active_members) which is defined in LbPool. When
            there are no backup members which are in the UP status, the
            number(min_active_members) would be ignored. PRIMARY_DOWN means
            that less than certain(min_active_members) primary members in
            default pool are in UP status but backup members are in UP status,
            the connections would be dispatched to backup members. DOWN means
            that all primary and backup members are in DOWN status. DETACHED
            means that the virtual server is not bound to any service. DISABLED
            means that the admin state of the virtual server is disabled.
            UNKNOWN means that no status reported from transport-nodes. The
            associated load balancer service may be working(or not working).
        :type  virtual_server_id: :class:`str` or ``None``
        :param virtual_server_id: load balancer virtual server identifier
        """
        self.last_update_timestamp = last_update_timestamp
        self.status = status
        self.virtual_server_id = virtual_server_id
        VapiStruct.__init__(self)


LbVirtualServerStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_virtual_server_status', {
        'last_update_timestamp': type.OptionalType(type.IntegerType()),
        'status': type.OptionalType(type.StringType()),
        'virtual_server_id': type.OptionalType(type.StringType()),
    },
    LbVirtualServerStatus,
    False,
    None))



class LbVirtualServerStatusListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`LbVirtualServerStatus` or ``None``
        :param results: paginated status list of virtual servers
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


LbVirtualServerStatusListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_virtual_server_status_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'LbVirtualServerStatus'))),
    },
    LbVirtualServerStatusListResult,
    False,
    None))



class LbVirtualServerWithRule(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'rules': 'rules',
                            'virtual_server': 'virtual_server',
                            }

    def __init__(self,
                 rules=None,
                 virtual_server=None,
                ):
        """
        :type  rules: :class:`list` of :class:`LbRule` or ``None``
        :param rules: It is used to add rules, update rules and bind rules to the virtual
            server. To add new rules, make sure that the rules have no
            identifier specified, the new rules are automatically generated and
            associated to the virtual server. If the virtual server need to
            consume some existed rules without change, those rules should not
            be specified in the list, otherwise, the rules are updated. For
            update_with_rules action, it supports rules delete and update. To
            delete old rules, the rules should not be configured in new action,
            the UUID of deleted rules should be removed from rule_ids. To
            update rules, the rules should be specified with new change and
            configured with identifier. If there are some rules which are not
            modified, those rule should not be specified in the rules list, the
            UUID list of rules should be specified in rule_ids of
            LbVirtualServer.
        :type  virtual_server: :class:`LbVirtualServer` or ``None``
        :param virtual_server: If rules need to be associated to the virtual server, please set
            rules properties of LbVirtualServerWithRule with rule list
            configuration. For the rules which are not modified but associated
            to the virtual server, the rule UUID list should be specified in
            rule_ids property of LbVirtualServer and the associated rules
            should not be specified in rules of LbVirtualServerWithRule.
        """
        self.rules = rules
        self.virtual_server = virtual_server
        VapiStruct.__init__(self)


LbVirtualServerWithRule._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lb_virtual_server_with_rule', {
        'rules': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'LbRule'))),
        'virtual_server': type.OptionalType(type.ReferenceType(__name__, 'LbVirtualServer')),
    },
    LbVirtualServerWithRule,
    False,
    None))



class Legend(VapiStruct):
    """
    Represents legend that describes the entities of the widget.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    ALIGNMENT_HORIZONTAL = "HORIZONTAL"
    """


    """
    ALIGNMENT_VERTICAL = "VERTICAL"
    """


    """
    POSITION_TOP = "TOP"
    """


    """
    POSITION_BOTTOM = "BOTTOM"
    """


    """
    POSITION_LEFT = "LEFT"
    """


    """
    POSITION_RIGHT = "RIGHT"
    """


    """
    POSITION_TOP_RIGHT = "TOP_RIGHT"
    """


    """
    TYPE_CIRCLE = "CIRCLE"
    """


    """



    _canonical_to_pep_names = {
                            'alignment': 'alignment',
                            'display_count': 'display_count',
                            'position': 'position',
                            'type': 'type',
                            'unit': 'unit',
                            }

    def __init__(self,
                 alignment=None,
                 display_count=None,
                 position=None,
                 type=None,
                 unit=None,
                ):
        """
        :type  alignment: :class:`str` or ``None``
        :param alignment: Possible values are: 
            
            * :attr:`Legend.ALIGNMENT_HORIZONTAL`
            * :attr:`Legend.ALIGNMENT_VERTICAL`
            
            Describes the alignment of legend. Alignment of a legend denotes
            how individual items of the legend are aligned in a container. For
            example, if VERTICAL is chosen then the items of the legend will
            appear one below the other and if HORIZONTAL is chosen then the
            items will appear side by side.
        :type  display_count: :class:`bool` or ``None``
        :param display_count: If set to true, it will display the counts in legend. If set to
            false, counts of entities are not displayed in the legend.
        :type  position: :class:`str` or ``None``
        :param position: Possible values are: 
            
            * :attr:`Legend.POSITION_TOP`
            * :attr:`Legend.POSITION_BOTTOM`
            * :attr:`Legend.POSITION_LEFT`
            * :attr:`Legend.POSITION_RIGHT`
            * :attr:`Legend.POSITION_TOP_RIGHT`
            
            Describes the relative placement of legend. The legend of a widget
            can be placed either to the TOP or BOTTOM or LEFT or RIGHT relative
            to the widget. For example, if RIGHT is chosen then legend is
            placed to the right of the widget.
        :type  type: :class:`str` or ``None``
        :param type: Possible values are: 
            
            * :attr:`Legend.TYPE_CIRCLE`
            
            Describes the render type for the legend. The legend for an entity
            describes the entity in the widget. The supported legend type is a
            circle against which the entity's details such as display_name are
            shown. The color of the circle denotes the color of the entity
            shown inside the widget.
        :type  unit: :class:`str` or ``None``
        :param unit: Show unit of entities in the legend.
        """
        self.alignment = alignment
        self.display_count = display_count
        self.position = position
        self.type = type
        self.unit = unit
        VapiStruct.__init__(self)


Legend._set_binding_type(type.StructType(
    'com.vmware.nsx.model.legend', {
        'alignment': type.OptionalType(type.StringType()),
        'display_count': type.OptionalType(type.BooleanType()),
        'position': type.OptionalType(type.StringType()),
        'type': type.OptionalType(type.StringType()),
        'unit': type.OptionalType(type.StringType()),
    },
    Legend,
    False,
    None))



class License(VapiStruct):
    """
    license properties

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    CAPACITY_TYPE_VM = "VM"
    """


    """
    CAPACITY_TYPE_CPU = "CPU"
    """


    """
    CAPACITY_TYPE_USER = "USER"
    """


    """
    CAPACITY_TYPE_CORE = "CORE"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'capacity_type': 'capacity_type',
                            'description': 'description',
                            'expiry': 'expiry',
                            'features': 'features',
                            'is_eval': 'is_eval',
                            'is_expired': 'is_expired',
                            'is_mh': 'is_mh',
                            'license_key': 'license_key',
                            'product_name': 'product_name',
                            'product_version': 'product_version',
                            'quantity': 'quantity',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 capacity_type=None,
                 description=None,
                 expiry=None,
                 features=None,
                 is_eval=None,
                 is_expired=None,
                 is_mh=None,
                 license_key=None,
                 product_name=None,
                 product_version=None,
                 quantity=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  capacity_type: :class:`str` or ``None``
        :param capacity_type: Possible values are: 
            
            * :attr:`License.CAPACITY_TYPE_VM`
            * :attr:`License.CAPACITY_TYPE_CPU`
            * :attr:`License.CAPACITY_TYPE_USER`
            * :attr:`License.CAPACITY_TYPE_CORE`
            
            License metrics specifying the capacity type of license key. Types
            are: - VM - CPU - USER(Concurrent User) - CORE
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: license edition
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  expiry: :class:`long` or ``None``
        :param expiry: date that license expires format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  features: :class:`str` or ``None``
        :param features: semicolon delimited feature list
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  is_eval: :class:`bool` or ``None``
        :param is_eval: true for evalution license
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  is_expired: :class:`bool` or ``None``
        :param is_expired: whether the license has expired
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  is_mh: :class:`bool` or ``None``
        :param is_mh: multi-hypervisor support
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  license_key: :class:`str` or ``None``
        :param license_key: license key
        :type  product_name: :class:`str` or ``None``
        :param product_name: product name
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  product_version: :class:`str` or ``None``
        :param product_version: product version
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  quantity: :class:`long` or ``None``
        :param quantity: license capacity; 0 for unlimited format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.capacity_type = capacity_type
        self.description = description
        self.expiry = expiry
        self.features = features
        self.is_eval = is_eval
        self.is_expired = is_expired
        self.is_mh = is_mh
        self.license_key = license_key
        self.product_name = product_name
        self.product_version = product_version
        self.quantity = quantity
        VapiStruct.__init__(self)


License._set_binding_type(type.StructType(
    'com.vmware.nsx.model.license', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'capacity_type': type.OptionalType(type.StringType()),
        'description': type.OptionalType(type.StringType()),
        'expiry': type.OptionalType(type.IntegerType()),
        'features': type.OptionalType(type.StringType()),
        'is_eval': type.OptionalType(type.BooleanType()),
        'is_expired': type.OptionalType(type.BooleanType()),
        'is_mh': type.OptionalType(type.BooleanType()),
        'license_key': type.OptionalType(type.StringType()),
        'product_name': type.OptionalType(type.StringType()),
        'product_version': type.OptionalType(type.StringType()),
        'quantity': type.OptionalType(type.IntegerType()),
    },
    License,
    False,
    None))



class LicensesListResult(VapiStruct):
    """
    Licenses queries result

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`License` or ``None``
        :param results: Licenses Results
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


LicensesListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.licenses_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'License'))),
    },
    LicensesListResult,
    False,
    None))



class ListResult(VapiStruct):
    """
    Base class for list results from collections

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        VapiStruct.__init__(self)


ListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
    },
    ListResult,
    False,
    None))



class ListResultQueryParameters(VapiStruct):
    """
    Parameters that affect how list results are processed

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'fields': 'fields',
                            }

    def __init__(self,
                 fields=None,
                ):
        """
        :type  fields: :class:`str` or ``None``
        :param fields: Comma-separated field names to include in query result
        """
        self.fields = fields
        VapiStruct.__init__(self)


ListResultQueryParameters._set_binding_type(type.StructType(
    'com.vmware.nsx.model.list_result_query_parameters', {
        'fields': type.OptionalType(type.StringType()),
    },
    ListResultQueryParameters,
    False,
    None))



class LldpHostSwitchProfile(VapiStruct):
    """
    Host Switch for LLDP

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LldpHostSwitchProfile"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'send_enabled': 'send_enabled',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'required_capabilities': 'required_capabilities',
                            }

    def __init__(self,
                 send_enabled=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='LldpHostSwitchProfile',
                 tags=None,
                 required_capabilities=None,
                ):
        """
        :type  send_enabled: :class:`bool` or ``None``
        :param send_enabled: Enabled or disabled sending LLDP packets
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            *
              :attr:`BaseHostSwitchProfile.RESOURCE_TYPE_UPLINKHOSTSWITCHPROFILE`
            * :attr:`BaseHostSwitchProfile.RESOURCE_TYPE_LLDPHOSTSWITCHPROFILE`
            * :attr:`BaseHostSwitchProfile.RESOURCE_TYPE_NIOCPROFILE`
            *
              :attr:`BaseHostSwitchProfile.RESOURCE_TYPE_EXTRACONFIGHOSTSWITCHPROFILE`
            
             Supported HostSwitch profiles.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  required_capabilities: :class:`list` of :class:`str` or ``None``
        :param required_capabilities: 
        """
        self.send_enabled = send_enabled
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        self.required_capabilities = required_capabilities
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

LldpHostSwitchProfile._set_binding_type(type.StructType(
    'com.vmware.nsx.model.lldp_host_switch_profile', {
        'send_enabled': type.OptionalType(type.BooleanType()),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'required_capabilities': type.OptionalType(type.ListType(type.StringType())),
    },
    LldpHostSwitchProfile,
    False,
    None))



class LoadBalancerAllocationPool(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LoadBalancerAllocationPool"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    ALLOCATION_SIZE_SMALL = "SMALL"
    """


    """
    ALLOCATION_SIZE_MEDIUM = "MEDIUM"
    """


    """
    ALLOCATION_SIZE_LARGE = "LARGE"
    """


    """
    ALLOCATION_SIZE_XLARGE = "XLARGE"
    """


    """



    _canonical_to_pep_names = {
                            'allocation_size': 'allocation_size',
                            'allocation_pool_type': 'allocation_pool_type',
                            }

    def __init__(self,
                 allocation_size=None,
                 allocation_pool_type='LoadBalancerAllocationPool',
                ):
        """
        :type  allocation_size: :class:`str` or ``None``
        :param allocation_size: Possible values are: 
            
            * :attr:`LoadBalancerAllocationPool.ALLOCATION_SIZE_SMALL`
            * :attr:`LoadBalancerAllocationPool.ALLOCATION_SIZE_MEDIUM`
            * :attr:`LoadBalancerAllocationPool.ALLOCATION_SIZE_LARGE`
            * :attr:`LoadBalancerAllocationPool.ALLOCATION_SIZE_XLARGE`
            
            To address varied customer performance and scalability
            requirements, different sizes for load balancer service are
            supported: SMALL, MEDIUM, LARGE and XLARGE, each with its own set
            of resource and performance. Specify size of load balancer service
            which you will bind to TIER1 router.
        :type  allocation_pool_type: :class:`str`
        :param allocation_pool_type: Possible values are: 
            
            *
              :attr:`EdgeClusterMemberAllocationPool.ALLOCATION_POOL_TYPE_LOADBALANCERALLOCATIONPOOL`
            
             Types of logical router allocation pool based on services
        """
        self.allocation_size = allocation_size
        self._allocation_pool_type = allocation_pool_type
        VapiStruct.__init__(self)

    @property
    def allocation_pool_type(self):
        """
        Return the discriminator value
        """
        return self._allocation_pool_type

LoadBalancerAllocationPool._set_binding_type(type.StructType(
    'com.vmware.nsx.model.load_balancer_allocation_pool', {
        'allocation_size': type.OptionalType(type.StringType()),
        'allocation_pool_type': type.StringType(),
    },
    LoadBalancerAllocationPool,
    False,
    None))



class LoggingServiceProperties(VapiStruct):
    """
    Service properties

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    LOGGING_LEVEL_OFF = "OFF"
    """


    """
    LOGGING_LEVEL_FATAL = "FATAL"
    """


    """
    LOGGING_LEVEL_ERROR = "ERROR"
    """


    """
    LOGGING_LEVEL_WARN = "WARN"
    """


    """
    LOGGING_LEVEL_INFO = "INFO"
    """


    """
    LOGGING_LEVEL_DEBUG = "DEBUG"
    """


    """
    LOGGING_LEVEL_TRACE = "TRACE"
    """


    """



    _canonical_to_pep_names = {
                            'logging_level': 'logging_level',
                            'modified_package_logging_levels': 'modified_package_logging_levels',
                            'package_logging_level': 'package_logging_level',
                            }

    def __init__(self,
                 logging_level=None,
                 modified_package_logging_levels=None,
                 package_logging_level=None,
                ):
        """
        :type  logging_level: :class:`str` or ``None``
        :param logging_level: Possible values are: 
            
            * :attr:`LoggingServiceProperties.LOGGING_LEVEL_OFF`
            * :attr:`LoggingServiceProperties.LOGGING_LEVEL_FATAL`
            * :attr:`LoggingServiceProperties.LOGGING_LEVEL_ERROR`
            * :attr:`LoggingServiceProperties.LOGGING_LEVEL_WARN`
            * :attr:`LoggingServiceProperties.LOGGING_LEVEL_INFO`
            * :attr:`LoggingServiceProperties.LOGGING_LEVEL_DEBUG`
            * :attr:`LoggingServiceProperties.LOGGING_LEVEL_TRACE`
            
             Service logging level
        :type  modified_package_logging_levels: :class:`str` or ``None``
        :param modified_package_logging_levels: Modified package logging levels
        :type  package_logging_level: :class:`list` of :class:`PackageLoggingLevels` or ``None``
        :param package_logging_level: Package logging levels
        """
        self.logging_level = logging_level
        self.modified_package_logging_levels = modified_package_logging_levels
        self.package_logging_level = package_logging_level
        VapiStruct.__init__(self)


LoggingServiceProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.logging_service_properties', {
        'logging_level': type.OptionalType(type.StringType()),
        'modified_package_logging_levels': type.OptionalType(type.StringType()),
        'package_logging_level': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'PackageLoggingLevels'))),
    },
    LoggingServiceProperties,
    False,
    None))



class LogicalConstructMigrationStats(VapiStruct):
    """
    Contains migration related information about logical constructs

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'source_count': 'source_count',
                            'source_type': 'source_type',
                            'target_count': 'target_count',
                            'target_type': 'target_type',
                            'vertical': 'vertical',
                            }

    def __init__(self,
                 source_count=None,
                 source_type=None,
                 target_count=None,
                 target_type=None,
                 vertical=None,
                ):
        """
        :type  source_count: :class:`str` or ``None``
        :param source_count: Number of objects of source type.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  source_type: :class:`str` or ``None``
        :param source_type: Type of the vSphere object (e.g. dvportgroup).
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  target_count: :class:`str` or ``None``
        :param target_count: Number of objects of target type.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  target_type: :class:`str` or ``None``
        :param target_type: Type of the Policy object corresponding to the source type (e.g.
            Segment).
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  vertical: :class:`str` or ``None``
        :param vertical: Functional area that this vSphere object falls into
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.source_count = source_count
        self.source_type = source_type
        self.target_count = target_count
        self.target_type = target_type
        self.vertical = vertical
        VapiStruct.__init__(self)


LogicalConstructMigrationStats._set_binding_type(type.StructType(
    'com.vmware.nsx.model.logical_construct_migration_stats', {
        'source_count': type.OptionalType(type.StringType()),
        'source_type': type.OptionalType(type.StringType()),
        'target_count': type.OptionalType(type.StringType()),
        'target_type': type.OptionalType(type.StringType()),
        'vertical': type.OptionalType(type.StringType()),
    },
    LogicalConstructMigrationStats,
    False,
    None))



class LogicalConstructMigrationStatsListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`LogicalConstructMigrationStats` or ``None``
        :param results: Paged collection of migration stats for logical constructs
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


LogicalConstructMigrationStatsListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.logical_construct_migration_stats_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'LogicalConstructMigrationStats'))),
    },
    LogicalConstructMigrationStatsListResult,
    False,
    None))



class LogicalDhcpServer(VapiStruct):
    """
    Definition of a logical DHCP server which can be attached a logical switch
    via a logical port. Both ipv4_dhcp_server and ipv6_dhcp_server can be
    configured at the same time, or only configure either ipv4_dhcp_server or
    ipv6_dhcp_server.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'attached_logical_port_id': 'attached_logical_port_id',
                            'dhcp_profile_id': 'dhcp_profile_id',
                            'ipv4_dhcp_server': 'ipv4_dhcp_server',
                            'ipv6_dhcp_server': 'ipv6_dhcp_server',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 attached_logical_port_id=None,
                 dhcp_profile_id=None,
                 ipv4_dhcp_server=None,
                 ipv6_dhcp_server=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  attached_logical_port_id: :class:`str` or ``None``
        :param attached_logical_port_id: The uuid of the attached logical port. Read only.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  dhcp_profile_id: :class:`str` or ``None``
        :param dhcp_profile_id: The DHCP profile uuid the logical DHCP server references.
        :type  ipv4_dhcp_server: :class:`IPv4DhcpServer` or ``None``
        :param ipv4_dhcp_server: The DHCP server for ipv4 addresses allocation service.
        :type  ipv6_dhcp_server: :class:`IPv6DhcpServer` or ``None``
        :param ipv6_dhcp_server: The DHCP server for ipv6 addresses allocation service.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.attached_logical_port_id = attached_logical_port_id
        self.dhcp_profile_id = dhcp_profile_id
        self.ipv4_dhcp_server = ipv4_dhcp_server
        self.ipv6_dhcp_server = ipv6_dhcp_server
        VapiStruct.__init__(self)


LogicalDhcpServer._set_binding_type(type.StructType(
    'com.vmware.nsx.model.logical_dhcp_server', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'attached_logical_port_id': type.OptionalType(type.StringType()),
        'dhcp_profile_id': type.OptionalType(type.StringType()),
        'ipv4_dhcp_server': type.OptionalType(type.ReferenceType(__name__, 'IPv4DhcpServer')),
        'ipv6_dhcp_server': type.OptionalType(type.ReferenceType(__name__, 'IPv6DhcpServer')),
    },
    LogicalDhcpServer,
    False,
    None))



class LogicalDhcpServerListResult(VapiStruct):
    """
    A paginated list of logical DHCP servers.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`LogicalDhcpServer` or ``None``
        :param results: A paginated list of logical DHCP servers.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


LogicalDhcpServerListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.logical_dhcp_server_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'LogicalDhcpServer'))),
    },
    LogicalDhcpServerListResult,
    False,
    None))



class LogicalPort(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    ADMIN_STATE_UP = "UP"
    """


    """
    ADMIN_STATE_DOWN = "DOWN"
    """


    """
    INIT_STATE_VLAN = "UNBLOCKED_VLAN"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'address_bindings': 'address_bindings',
                            'admin_state': 'admin_state',
                            'attachment': 'attachment',
                            'extra_configs': 'extra_configs',
                            'ignore_address_bindings': 'ignore_address_bindings',
                            'init_state': 'init_state',
                            'internal_id': 'internal_id',
                            'logical_switch_id': 'logical_switch_id',
                            'switching_profile_ids': 'switching_profile_ids',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 address_bindings=None,
                 admin_state=None,
                 attachment=None,
                 extra_configs=None,
                 ignore_address_bindings=None,
                 init_state=None,
                 internal_id=None,
                 logical_switch_id=None,
                 switching_profile_ids=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  address_bindings: :class:`list` of :class:`PacketAddressClassifier` or ``None``
        :param address_bindings: Each address binding must contain both an IPElement and MAC
            address. VLAN ID is optional. This binding configuration can be
            used by features such as spoof-guard and overrides any discovered
            bindings. Any non unique entries are deduplicated to generate a
            unique set of address bindings and then stored. For IPv6 addresses,
            a subnet address cannot have host bits set. A maximum of 128 unique
            address bindings is allowed per port.
        :type  admin_state: :class:`str` or ``None``
        :param admin_state: Possible values are: 
            
            * :attr:`LogicalPort.ADMIN_STATE_UP`
            * :attr:`LogicalPort.ADMIN_STATE_DOWN`
            
             Represents Desired state of the logical port
        :type  attachment: :class:`LogicalPortAttachment` or ``None``
        :param attachment: Logical port attachment
        :type  extra_configs: :class:`list` of :class:`ExtraConfig` or ``None``
        :param extra_configs: This property could be used for vendor specific configuration in
            key value string pairs. Logical port setting will override logical
            switch setting if the same key was set on both logical switch and
            logical port.
        :type  ignore_address_bindings: :class:`list` of :class:`PacketAddressClassifier` or ``None``
        :param ignore_address_bindings: IP Discovery module uses various mechanisms to discover address
            bindings being used on each port. If a user would like to ignore
            any specific discovered address bindings or prevent the discovery
            of a particular set of discovered bindings, then those address
            bindings can be provided here. Currently IP range in CIDR format is
            not supported.
        :type  init_state: :class:`str` or ``None``
        :param init_state: Possible values are: 
            
            * :attr:`LogicalPort.INIT_STATE_VLAN`
            
            Set initial state when a new logical port is created.
            'UNBLOCKED_VLAN' means new port will be unblocked on traffic in
            creation, also VLAN will be set with corresponding logical switch
            setting. This port setting can only be configured at port creation
            (POST), and cannot be modified.
        :type  internal_id: :class:`str` or ``None``
        :param internal_id: The internal_id of the logical port may or may not be identical to
            it's managed resource ID. If a VirtualMachine connected to logical
            port migrates from one site to another, then on the destination
            site, it will be connected to different logical port managed
            resource. However, the internal_id field will be persisted across
            vmotion.
        :type  logical_switch_id: :class:`str` or ``None``
        :param logical_switch_id: Id of the Logical switch that this port belongs to.
        :type  switching_profile_ids: :class:`list` of :class:`SwitchingProfileTypeIdEntry` or ``None``
        :param switching_profile_ids: 
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.address_bindings = address_bindings
        self.admin_state = admin_state
        self.attachment = attachment
        self.extra_configs = extra_configs
        self.ignore_address_bindings = ignore_address_bindings
        self.init_state = init_state
        self.internal_id = internal_id
        self.logical_switch_id = logical_switch_id
        self.switching_profile_ids = switching_profile_ids
        VapiStruct.__init__(self)


LogicalPort._set_binding_type(type.StructType(
    'com.vmware.nsx.model.logical_port', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'address_bindings': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'PacketAddressClassifier'))),
        'admin_state': type.OptionalType(type.StringType()),
        'attachment': type.OptionalType(type.ReferenceType(__name__, 'LogicalPortAttachment')),
        'extra_configs': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ExtraConfig'))),
        'ignore_address_bindings': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'PacketAddressClassifier'))),
        'init_state': type.OptionalType(type.StringType()),
        'internal_id': type.OptionalType(type.StringType()),
        'logical_switch_id': type.OptionalType(type.StringType()),
        'switching_profile_ids': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'SwitchingProfileTypeIdEntry'))),
    },
    LogicalPort,
    False,
    None))



class LogicalPortAttachment(VapiStruct):
    """
    Logical port attachment

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    ATTACHMENT_TYPE_VIF = "VIF"
    """


    """
    ATTACHMENT_TYPE_LOGICALROUTER = "LOGICALROUTER"
    """


    """
    ATTACHMENT_TYPE_BRIDGEENDPOINT = "BRIDGEENDPOINT"
    """


    """
    ATTACHMENT_TYPE_DHCP_SERVICE = "DHCP_SERVICE"
    """


    """
    ATTACHMENT_TYPE_METADATA_PROXY = "METADATA_PROXY"
    """


    """
    ATTACHMENT_TYPE_L2VPN_SESSION = "L2VPN_SESSION"
    """


    """
    ATTACHMENT_TYPE_L2FORWARDER = "L2FORWARDER"
    """


    """



    _canonical_to_pep_names = {
                            'attachment_type': 'attachment_type',
                            'context': 'context',
                            'id': 'id',
                            }

    def __init__(self,
                 attachment_type=None,
                 context=None,
                 id=None,
                ):
        """
        :type  attachment_type: :class:`str` or ``None``
        :param attachment_type: Possible values are: 
            
            * :attr:`LogicalPortAttachment.ATTACHMENT_TYPE_VIF`
            * :attr:`LogicalPortAttachment.ATTACHMENT_TYPE_LOGICALROUTER`
            * :attr:`LogicalPortAttachment.ATTACHMENT_TYPE_BRIDGEENDPOINT`
            * :attr:`LogicalPortAttachment.ATTACHMENT_TYPE_DHCP_SERVICE`
            * :attr:`LogicalPortAttachment.ATTACHMENT_TYPE_METADATA_PROXY`
            * :attr:`LogicalPortAttachment.ATTACHMENT_TYPE_L2VPN_SESSION`
            * :attr:`LogicalPortAttachment.ATTACHMENT_TYPE_L2FORWARDER`
            
            Indicates the type of logical port attachment. By default it is
            Virtual Machine interface (VIF)
        :type  context: :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param context: Extra context data for the attachment
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`AttachmentContext`. When methods return a value of this
            class as a return value, the attribute will contain all the
            attributes defined in :class:`AttachmentContext`.
        :type  id: :class:`str` or ``None``
        :param id: Identifier of the interface attached to the logical port
        """
        self.attachment_type = attachment_type
        self.context = context
        self.id = id
        VapiStruct.__init__(self)


LogicalPortAttachment._set_binding_type(type.StructType(
    'com.vmware.nsx.model.logical_port_attachment', {
        'attachment_type': type.OptionalType(type.StringType()),
        'context': type.OptionalType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'AttachmentContext')])),
        'id': type.OptionalType(type.StringType()),
    },
    LogicalPortAttachment,
    False,
    None))



class LogicalPortAttachmentState(VapiStruct):
    """
    VIF attachment state of a logical port

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATE_FREE = "FREE"
    """


    """
    STATE_ATTACHED = "ATTACHED"
    """


    """
    STATE_ATTACHED_PENDING_CONF = "ATTACHED_PENDING_CONF"
    """


    """
    STATE_ATTACHED_IN_MOTION = "ATTACHED_IN_MOTION"
    """


    """
    STATE_DETACHED = "DETACHED"
    """


    """



    _canonical_to_pep_names = {
                            'attachers': 'attachers',
                            'id': 'id',
                            'state': 'state',
                            }

    def __init__(self,
                 attachers=None,
                 id=None,
                 state=None,
                ):
        """
        :type  attachers: :class:`list` of :class:`PortAttacher` or ``None``
        :param attachers: VM or vmknic entities that are attached to the LogicalPort
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  id: :class:`str` or ``None``
        :param id: VIF ID
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  state: :class:`str` or ``None``
        :param state: Possible values are: 
            
            * :attr:`LogicalPortAttachmentState.STATE_FREE`
            * :attr:`LogicalPortAttachmentState.STATE_ATTACHED`
            * :attr:`LogicalPortAttachmentState.STATE_ATTACHED_PENDING_CONF`
            * :attr:`LogicalPortAttachmentState.STATE_ATTACHED_IN_MOTION`
            * :attr:`LogicalPortAttachmentState.STATE_DETACHED`
            
            A logicalPort must be in one of following state. FREE - If there
            are no active attachers. The LogicalPort may or may not have an
            attachment ID configured on it. This state is applicable only to
            LogialPort of static type. ATTACHED - LogicalPort has exactly one
            active attacher and no further configuration is pending.
            ATTACHED_PENDING_CONF - LogicalPort has exactly one attacher,
            however it may not have been configured completely. Additional
            configuration will be provided by other nsx components.
            ATTACHED_IN_MOTION - LogicalPort has multiple active attachers.
            This state represents a scenario where VM is moving from one
            location (host or storage) to another (e.g. vmotion, vSphere HA)
            DETACHED - A temporary state after all LogialPort attachers have
            been detached. This state is applicable only to LogicalPort of
            ephemeral type and the LogicalPort will soon be deleted.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.attachers = attachers
        self.id = id
        self.state = state
        VapiStruct.__init__(self)


LogicalPortAttachmentState._set_binding_type(type.StructType(
    'com.vmware.nsx.model.logical_port_attachment_state', {
        'attachers': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'PortAttacher'))),
        'id': type.OptionalType(type.StringType()),
        'state': type.OptionalType(type.StringType()),
    },
    LogicalPortAttachmentState,
    False,
    None))



class LogicalPortListResult(VapiStruct):
    """
    Logical port queries result

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`LogicalPort` or ``None``
        :param results: LogicalPort Results
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


LogicalPortListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.logical_port_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'LogicalPort'))),
    },
    LogicalPortListResult,
    False,
    None))



class LogicalPortMacAddressCsvListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'file_name': 'file_name',
                            'last_update_timestamp': 'last_update_timestamp',
                            'results': 'results',
                            }

    def __init__(self,
                 file_name=None,
                 last_update_timestamp=None,
                 results=None,
                ):
        """
        :type  file_name: :class:`str` or ``None``
        :param file_name: File name set by HTTP server if API returns CSV result as a file.
        :type  last_update_timestamp: :class:`long` or ``None``
        :param last_update_timestamp: Timestamp when the data was last updated; unset if data source has
            never updated the data. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`LogicalPortMacTableCsvEntry` or ``None``
        :param results: 
        """
        self.file_name = file_name
        self.last_update_timestamp = last_update_timestamp
        self.results = results
        VapiStruct.__init__(self)


LogicalPortMacAddressCsvListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.logical_port_mac_address_csv_list_result', {
        'file_name': type.OptionalType(type.StringType()),
        'last_update_timestamp': type.OptionalType(type.IntegerType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'LogicalPortMacTableCsvEntry'))),
    },
    LogicalPortMacAddressCsvListResult,
    False,
    None))



class LogicalPortMacAddressListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'last_update_timestamp': 'last_update_timestamp',
                            'logical_port_id': 'logical_port_id',
                            'results': 'results',
                            'transport_node_id': 'transport_node_id',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 last_update_timestamp=None,
                 logical_port_id=None,
                 results=None,
                 transport_node_id=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_update_timestamp: :class:`long` or ``None``
        :param last_update_timestamp: Timestamp when the data was last updated; unset if data source has
            never updated the data. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  logical_port_id: :class:`str` or ``None``
        :param logical_port_id: The id of the logical port
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`LogicalPortMacTableEntry` or ``None``
        :param results: 
        :type  transport_node_id: :class:`str` or ``None``
        :param transport_node_id: Transport node identifier
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.last_update_timestamp = last_update_timestamp
        self.logical_port_id = logical_port_id
        self.results = results
        self.transport_node_id = transport_node_id
        VapiStruct.__init__(self)


LogicalPortMacAddressListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.logical_port_mac_address_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'last_update_timestamp': type.OptionalType(type.IntegerType()),
        'logical_port_id': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'LogicalPortMacTableEntry'))),
        'transport_node_id': type.OptionalType(type.StringType()),
    },
    LogicalPortMacAddressListResult,
    False,
    None))



class LogicalPortMacTableCsvEntry(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    MAC_TYPE_STATIC = "STATIC"
    """


    """
    MAC_TYPE_LEARNED = "LEARNED"
    """


    """



    _canonical_to_pep_names = {
                            'mac_address': 'mac_address',
                            'mac_type': 'mac_type',
                            }

    def __init__(self,
                 mac_address=None,
                 mac_type=None,
                ):
        """
        :type  mac_address: :class:`str` or ``None``
        :param mac_address: The MAC address
        :type  mac_type: :class:`str` or ``None``
        :param mac_type: Possible values are: 
            
            * :attr:`LogicalPortMacTableCsvEntry.MAC_TYPE_STATIC`
            * :attr:`LogicalPortMacTableCsvEntry.MAC_TYPE_LEARNED`
            
             The type of the MAC address
        """
        self.mac_address = mac_address
        self.mac_type = mac_type
        VapiStruct.__init__(self)


LogicalPortMacTableCsvEntry._set_binding_type(type.StructType(
    'com.vmware.nsx.model.logical_port_mac_table_csv_entry', {
        'mac_address': type.OptionalType(type.StringType()),
        'mac_type': type.OptionalType(type.StringType()),
    },
    LogicalPortMacTableCsvEntry,
    False,
    None))



class LogicalPortMacTableEntry(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    MAC_TYPE_STATIC = "STATIC"
    """


    """
    MAC_TYPE_LEARNED = "LEARNED"
    """


    """



    _canonical_to_pep_names = {
                            'mac_address': 'mac_address',
                            'mac_type': 'mac_type',
                            }

    def __init__(self,
                 mac_address=None,
                 mac_type=None,
                ):
        """
        :type  mac_address: :class:`str` or ``None``
        :param mac_address: The MAC address
        :type  mac_type: :class:`str` or ``None``
        :param mac_type: Possible values are: 
            
            * :attr:`LogicalPortMacTableEntry.MAC_TYPE_STATIC`
            * :attr:`LogicalPortMacTableEntry.MAC_TYPE_LEARNED`
            
             The type of the MAC address
        """
        self.mac_address = mac_address
        self.mac_type = mac_type
        VapiStruct.__init__(self)


LogicalPortMacTableEntry._set_binding_type(type.StructType(
    'com.vmware.nsx.model.logical_port_mac_table_entry', {
        'mac_address': type.OptionalType(type.StringType()),
        'mac_type': type.OptionalType(type.StringType()),
    },
    LogicalPortMacTableEntry,
    False,
    None))



class LogicalPortMirrorDestination(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LogicalPortMirrorDestination"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'port_ids': 'port_ids',
                            'resource_type': 'resource_type',
                            }

    def __init__(self,
                 port_ids=None,
                 resource_type='LogicalPortMirrorDestination',
                ):
        """
        :type  port_ids: :class:`list` of :class:`str` or ``None``
        :param port_ids: Destination logical port identifier list.
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            *
              :attr:`MirrorDestination.RESOURCE_TYPE_LOGICALPORTMIRRORDESTINATION`
            * :attr:`MirrorDestination.RESOURCE_TYPE_PNICMIRRORDESTINATION`
            * :attr:`MirrorDestination.RESOURCE_TYPE_IPMIRRORDESTINATION`
            
             Resource types of mirror destination
        """
        self.port_ids = port_ids
        self._resource_type = resource_type
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

LogicalPortMirrorDestination._set_binding_type(type.StructType(
    'com.vmware.nsx.model.logical_port_mirror_destination', {
        'port_ids': type.OptionalType(type.ListType(type.StringType())),
        'resource_type': type.StringType(),
    },
    LogicalPortMirrorDestination,
    False,
    None))



class LogicalPortMirrorSource(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LogicalPortMirrorSource"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'port_ids': 'port_ids',
                            'resource_type': 'resource_type',
                            }

    def __init__(self,
                 port_ids=None,
                 resource_type='LogicalPortMirrorSource',
                ):
        """
        :type  port_ids: :class:`list` of :class:`str` or ``None``
        :param port_ids: Source logical port identifier list
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`MirrorSource.RESOURCE_TYPE_LOGICALPORTMIRRORSOURCE`
            * :attr:`MirrorSource.RESOURCE_TYPE_PNICMIRRORSOURCE`
            * :attr:`MirrorSource.RESOURCE_TYPE_VLANMIRRORSOURCE`
            * :attr:`MirrorSource.RESOURCE_TYPE_LOGICALSWITCHMIRRORSOURCE`
            
             Resource types of mirror source
        """
        self.port_ids = port_ids
        self._resource_type = resource_type
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

LogicalPortMirrorSource._set_binding_type(type.StructType(
    'com.vmware.nsx.model.logical_port_mirror_source', {
        'port_ids': type.OptionalType(type.ListType(type.StringType())),
        'resource_type': type.StringType(),
    },
    LogicalPortMirrorSource,
    False,
    None))



class LogicalPortOperationalStatus(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATUS_UP = "UP"
    """


    """
    STATUS_DOWN = "DOWN"
    """


    """
    STATUS_UNKNOWN = "UNKNOWN"
    """


    """



    _canonical_to_pep_names = {
                            'last_update_timestamp': 'last_update_timestamp',
                            'logical_port_id': 'logical_port_id',
                            'status': 'status',
                            }

    def __init__(self,
                 last_update_timestamp=None,
                 logical_port_id=None,
                 status=None,
                ):
        """
        :type  last_update_timestamp: :class:`long` or ``None``
        :param last_update_timestamp: Timestamp when the data was last updated; unset if data source has
            never updated the data. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  logical_port_id: :class:`str` or ``None``
        :param logical_port_id: The id of the logical port
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  status: :class:`str` or ``None``
        :param status: Possible values are: 
            
            * :attr:`LogicalPortOperationalStatus.STATUS_UP`
            * :attr:`LogicalPortOperationalStatus.STATUS_DOWN`
            * :attr:`LogicalPortOperationalStatus.STATUS_UNKNOWN`
            
             The Operational status of the logical port
        """
        self.last_update_timestamp = last_update_timestamp
        self.logical_port_id = logical_port_id
        self.status = status
        VapiStruct.__init__(self)


LogicalPortOperationalStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.logical_port_operational_status', {
        'last_update_timestamp': type.OptionalType(type.IntegerType()),
        'logical_port_id': type.OptionalType(type.StringType()),
        'status': type.OptionalType(type.StringType()),
    },
    LogicalPortOperationalStatus,
    False,
    None))



class LogicalPortState(VapiStruct):
    """
    Contians realized state of the logical port. For example, transport node on
    which the port is located, discovered and realized address bindings of the
    logical port.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'attachment': 'attachment',
                            'discovered_bindings': 'discovered_bindings',
                            'duplicate_bindings': 'duplicate_bindings',
                            'id': 'id',
                            'realized_bindings': 'realized_bindings',
                            'transport_node_ids': 'transport_node_ids',
                            }

    def __init__(self,
                 attachment=None,
                 discovered_bindings=None,
                 duplicate_bindings=None,
                 id=None,
                 realized_bindings=None,
                 transport_node_ids=None,
                ):
        """
        :type  attachment: :class:`LogicalPortAttachmentState` or ``None``
        :param attachment: Logical port attachment state
        :type  discovered_bindings: :class:`list` of :class:`AddressBindingEntry` or ``None``
        :param discovered_bindings: Contains the list of address bindings for a logical port that were
            automatically dicovered using various snooping methods like ARP,
            DHCP etc.
        :type  duplicate_bindings: :class:`list` of :class:`DuplicateAddressBindingEntry` or ``None``
        :param duplicate_bindings: If any address binding discovered on the port is also found on
            other port on the same logical switch, then it is included in the
            duplicate bindings list along with the ID of the port with which it
            conflicts.
        :type  id: :class:`str` or ``None``
        :param id: Id of the logical port
        :type  realized_bindings: :class:`list` of :class:`AddressBindingEntry` or ``None``
        :param realized_bindings: List of logical port bindings that are realized. This list may be
            populated from the discovered bindings or manual user specified
            bindings. This binding configuration can be used by features such
            as firewall, spoof-guard, traceflow etc.
        :type  transport_node_ids: :class:`list` of :class:`str` or ``None``
        :param transport_node_ids: Identifiers of the transport node where the port is located
        """
        self.attachment = attachment
        self.discovered_bindings = discovered_bindings
        self.duplicate_bindings = duplicate_bindings
        self.id = id
        self.realized_bindings = realized_bindings
        self.transport_node_ids = transport_node_ids
        VapiStruct.__init__(self)


LogicalPortState._set_binding_type(type.StructType(
    'com.vmware.nsx.model.logical_port_state', {
        'attachment': type.OptionalType(type.ReferenceType(__name__, 'LogicalPortAttachmentState')),
        'discovered_bindings': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'AddressBindingEntry'))),
        'duplicate_bindings': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'DuplicateAddressBindingEntry'))),
        'id': type.OptionalType(type.StringType()),
        'realized_bindings': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'AddressBindingEntry'))),
        'transport_node_ids': type.OptionalType(type.ListType(type.StringType())),
    },
    LogicalPortState,
    False,
    None))



class LogicalPortStatistics(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'rx_bytes': 'rx_bytes',
                            'rx_packets': 'rx_packets',
                            'tx_bytes': 'tx_bytes',
                            'tx_packets': 'tx_packets',
                            'dropped_by_security_packets': 'dropped_by_security_packets',
                            'mac_learning': 'mac_learning',
                            'last_update_timestamp': 'last_update_timestamp',
                            'logical_port_id': 'logical_port_id',
                            }

    def __init__(self,
                 rx_bytes=None,
                 rx_packets=None,
                 tx_bytes=None,
                 tx_packets=None,
                 dropped_by_security_packets=None,
                 mac_learning=None,
                 last_update_timestamp=None,
                 logical_port_id=None,
                ):
        """
        :type  rx_bytes: :class:`DataCounter` or ``None``
        :param rx_bytes: 
        :type  rx_packets: :class:`DataCounter` or ``None``
        :param rx_packets: 
        :type  tx_bytes: :class:`DataCounter` or ``None``
        :param tx_bytes: 
        :type  tx_packets: :class:`DataCounter` or ``None``
        :param tx_packets: 
        :type  dropped_by_security_packets: :class:`PacketsDroppedBySecurity` or ``None``
        :param dropped_by_security_packets: 
        :type  mac_learning: :class:`MacLearningCounters` or ``None``
        :param mac_learning: 
        :type  last_update_timestamp: :class:`long` or ``None``
        :param last_update_timestamp: Timestamp when the data was last updated; unset if data source has
            never updated the data. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  logical_port_id: :class:`str` or ``None``
        :param logical_port_id: The id of the logical port
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.rx_bytes = rx_bytes
        self.rx_packets = rx_packets
        self.tx_bytes = tx_bytes
        self.tx_packets = tx_packets
        self.dropped_by_security_packets = dropped_by_security_packets
        self.mac_learning = mac_learning
        self.last_update_timestamp = last_update_timestamp
        self.logical_port_id = logical_port_id
        VapiStruct.__init__(self)


LogicalPortStatistics._set_binding_type(type.StructType(
    'com.vmware.nsx.model.logical_port_statistics', {
        'rx_bytes': type.OptionalType(type.ReferenceType(__name__, 'DataCounter')),
        'rx_packets': type.OptionalType(type.ReferenceType(__name__, 'DataCounter')),
        'tx_bytes': type.OptionalType(type.ReferenceType(__name__, 'DataCounter')),
        'tx_packets': type.OptionalType(type.ReferenceType(__name__, 'DataCounter')),
        'dropped_by_security_packets': type.OptionalType(type.ReferenceType(__name__, 'PacketsDroppedBySecurity')),
        'mac_learning': type.OptionalType(type.ReferenceType(__name__, 'MacLearningCounters')),
        'last_update_timestamp': type.OptionalType(type.IntegerType()),
        'logical_port_id': type.OptionalType(type.StringType()),
    },
    LogicalPortStatistics,
    False,
    None))



class LogicalPortStatusSummary(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'filters': 'filters',
                            'last_update_timestamp': 'last_update_timestamp',
                            'total_ports': 'total_ports',
                            'up_ports': 'up_ports',
                            }

    def __init__(self,
                 filters=None,
                 last_update_timestamp=None,
                 total_ports=None,
                 up_ports=None,
                ):
        """
        :type  filters: :class:`list` of :class:`Filter` or ``None``
        :param filters: The filters used to find the logical ports- TransportZone id,
            LogicalSwitch id or LogicalSwitchProfile id
        :type  last_update_timestamp: :class:`long` or ``None``
        :param last_update_timestamp: Timestamp when the data was last updated; unset if data source has
            never updated the data. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  total_ports: :class:`long` or ``None``
        :param total_ports: The total number of logical ports. format: int64
        :type  up_ports: :class:`long` or ``None``
        :param up_ports: The number of logical ports whose Operational status is UP format:
            int64
        """
        self.filters = filters
        self.last_update_timestamp = last_update_timestamp
        self.total_ports = total_ports
        self.up_ports = up_ports
        VapiStruct.__init__(self)


LogicalPortStatusSummary._set_binding_type(type.StructType(
    'com.vmware.nsx.model.logical_port_status_summary', {
        'filters': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Filter'))),
        'last_update_timestamp': type.OptionalType(type.IntegerType()),
        'total_ports': type.OptionalType(type.IntegerType()),
        'up_ports': type.OptionalType(type.IntegerType()),
    },
    LogicalPortStatusSummary,
    False,
    None))



class LogicalRouter(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    FAILOVER_MODE_PREEMPTIVE = "PREEMPTIVE"
    """


    """
    FAILOVER_MODE_NON_PREEMPTIVE = "NON_PREEMPTIVE"
    """


    """
    HIGH_AVAILABILITY_MODE_ACTIVE = "ACTIVE_ACTIVE"
    """


    """
    HIGH_AVAILABILITY_MODE_STANDBY = "ACTIVE_STANDBY"
    """


    """
    ROUTER_TYPE_TIER0 = "TIER0"
    """


    """
    ROUTER_TYPE_TIER1 = "TIER1"
    """


    """
    ROUTER_TYPE_VRF = "VRF"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'advanced_config': 'advanced_config',
                            'allocation_profile': 'allocation_profile',
                            'edge_cluster_id': 'edge_cluster_id',
                            'edge_cluster_member_indices': 'edge_cluster_member_indices',
                            'failover_mode': 'failover_mode',
                            'firewall_sections': 'firewall_sections',
                            'high_availability_mode': 'high_availability_mode',
                            'ipv6_profiles': 'ipv6_profiles',
                            'preferred_edge_cluster_member_index': 'preferred_edge_cluster_member_index',
                            'router_type': 'router_type',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 advanced_config=None,
                 allocation_profile=None,
                 edge_cluster_id=None,
                 edge_cluster_member_indices=None,
                 failover_mode=None,
                 firewall_sections=None,
                 high_availability_mode=None,
                 ipv6_profiles=None,
                 preferred_edge_cluster_member_index=None,
                 router_type=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  advanced_config: :class:`LogicalRouterConfig` or ``None``
        :param advanced_config: Contains config properties for tier0 routers
        :type  allocation_profile: :class:`EdgeClusterMemberAllocationProfile` or ``None``
        :param allocation_profile: Configurations options to auto allocate edge cluster members for
            logical router. Auto allocation is supported only for TIER1 and
            pick least utilized member post current assignment for next
            allocation.
        :type  edge_cluster_id: :class:`str` or ``None``
        :param edge_cluster_id: Used for tier0 routers
        :type  edge_cluster_member_indices: :class:`list` of :class:`long` or ``None``
        :param edge_cluster_member_indices: For stateful services, the logical router should be associated with
            edge cluster. For TIER 1 logical router, for manual placement of
            service router within the cluster, edge cluster member indices
            needs to be provided else same will be auto-allocated. You can
            provide maximum two indices for HA ACTIVE_STANDBY. For TIER0
            logical router this property is no use and placement is derived
            from logical router uplink or loopback port. format: int64
        :type  failover_mode: :class:`str` or ``None``
        :param failover_mode: Possible values are: 
            
            * :attr:`LogicalRouter.FAILOVER_MODE_PREEMPTIVE`
            * :attr:`LogicalRouter.FAILOVER_MODE_NON_PREEMPTIVE`
            
            Determines the behavior when a logical router instance restarts
            after a failure. If set to PREEMPTIVE, the preferred node will take
            over, even if it causes another failure. If set to NON_PREEMPTIVE,
            then the instance that restarted will remain secondary. This
            property must not be populated unless the high_availability_mode
            property is set to ACTIVE_STANDBY. If high_availability_mode
            property is set to ACTIVE_STANDBY and this property is not
            specified then default will be NON_PREEMPTIVE.
        :type  firewall_sections: :class:`list` of :class:`ResourceReference` or ``None``
        :param firewall_sections: List of Firewall sections related to Logical Router.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  high_availability_mode: :class:`str` or ``None``
        :param high_availability_mode: Possible values are: 
            
            * :attr:`LogicalRouter.HIGH_AVAILABILITY_MODE_ACTIVE`
            * :attr:`LogicalRouter.HIGH_AVAILABILITY_MODE_STANDBY`
            
             High availability mode
        :type  ipv6_profiles: :class:`IPv6Profiles` or ``None``
        :param ipv6_profiles: IPv6Profiles captures IPv6 NDRA Profile and DAD Profile id
            associated with the logical router.
        :type  preferred_edge_cluster_member_index: :class:`long` or ``None``
        :param preferred_edge_cluster_member_index: Preferred edge cluster member index which is required for
            PREEMPTIVE failover mode. Used for Tier0 routers only. format:
            int64
        :type  router_type: :class:`str` or ``None``
        :param router_type: Possible values are: 
            
            * :attr:`LogicalRouter.ROUTER_TYPE_TIER0`
            * :attr:`LogicalRouter.ROUTER_TYPE_TIER1`
            * :attr:`LogicalRouter.ROUTER_TYPE_VRF`
            
            TIER0 for external connectivity. TIER1 for two tier topology with
            TIER0 on top. VRF for isolation of routing table on TIER0.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.advanced_config = advanced_config
        self.allocation_profile = allocation_profile
        self.edge_cluster_id = edge_cluster_id
        self.edge_cluster_member_indices = edge_cluster_member_indices
        self.failover_mode = failover_mode
        self.firewall_sections = firewall_sections
        self.high_availability_mode = high_availability_mode
        self.ipv6_profiles = ipv6_profiles
        self.preferred_edge_cluster_member_index = preferred_edge_cluster_member_index
        self.router_type = router_type
        VapiStruct.__init__(self)


LogicalRouter._set_binding_type(type.StructType(
    'com.vmware.nsx.model.logical_router', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'advanced_config': type.OptionalType(type.ReferenceType(__name__, 'LogicalRouterConfig')),
        'allocation_profile': type.OptionalType(type.ReferenceType(__name__, 'EdgeClusterMemberAllocationProfile')),
        'edge_cluster_id': type.OptionalType(type.StringType()),
        'edge_cluster_member_indices': type.OptionalType(type.ListType(type.IntegerType())),
        'failover_mode': type.OptionalType(type.StringType()),
        'firewall_sections': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceReference'))),
        'high_availability_mode': type.OptionalType(type.StringType()),
        'ipv6_profiles': type.OptionalType(type.ReferenceType(__name__, 'IPv6Profiles')),
        'preferred_edge_cluster_member_index': type.OptionalType(type.IntegerType()),
        'router_type': type.OptionalType(type.StringType()),
    },
    LogicalRouter,
    False,
    None))



class LogicalRouterCentralizedServicePort(VapiStruct):
    """
    This port can be configured on both TIER0 and TIER1 logical router. Port
    can be connected to VLAN or overlay logical switch. Unlike downlink port it
    does not participate in distributed routing and hosted on all edge cluster
    members associated with logical router. Stateful services can be applied on
    this port.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LogicalRouterCentralizedServicePort"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    URPF_MODE_NONE = "NONE"
    """


    """
    URPF_MODE_STRICT = "STRICT"
    """


    """



    _canonical_to_pep_names = {
                            'enable_netx': 'enable_netx',
                            'linked_logical_switch_port_id': 'linked_logical_switch_port_id',
                            'mtu': 'mtu',
                            'ndra_profile_id': 'ndra_profile_id',
                            'subnets': 'subnets',
                            'urpf_mode': 'urpf_mode',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'logical_router_id': 'logical_router_id',
                            'service_bindings': 'service_bindings',
                            }

    def __init__(self,
                 enable_netx=None,
                 linked_logical_switch_port_id=None,
                 mtu=None,
                 ndra_profile_id=None,
                 subnets=None,
                 urpf_mode=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='LogicalRouterCentralizedServicePort',
                 tags=None,
                 logical_router_id=None,
                 service_bindings=None,
                ):
        """
        :type  enable_netx: :class:`bool` or ``None``
        :param enable_netx: Port is exclusively used for N-S service insertion
        :type  linked_logical_switch_port_id: :class:`ResourceReference` or ``None``
        :param linked_logical_switch_port_id: Reference to the logical switch port to connect to
        :type  mtu: :class:`long` or ``None``
        :param mtu: Maximum transmission unit specifies the size of the largest packet
            that a network protocol can transmit. If not specified, the global
            logical MTU set in the /api/v1/global-configs/RoutingGlobalConfig
            API will be used. format: int64
        :type  ndra_profile_id: :class:`str` or ``None``
        :param ndra_profile_id: Identifier of Neighbor Discovery Router Advertisement profile
            associated with port. When NDRA profile id is associated at both
            the port level and logical router level, the profile id specified
            at port level takes the precedence.
        :type  subnets: :class:`list` of :class:`IPSubnet` or ``None``
        :param subnets: Logical router port subnets
        :type  urpf_mode: :class:`str` or ``None``
        :param urpf_mode: Possible values are: 
            
            * :attr:`LogicalRouterCentralizedServicePort.URPF_MODE_NONE`
            * :attr:`LogicalRouterCentralizedServicePort.URPF_MODE_STRICT`
            
             Unicast Reverse Path Forwarding mode
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`LogicalRouterPort.RESOURCE_TYPE_LOGICALROUTERUPLINKPORT`
            * :attr:`LogicalRouterPort.RESOURCE_TYPE_LOGICALROUTERDOWNLINKPORT`
            *
              :attr:`LogicalRouterPort.RESOURCE_TYPE_LOGICALROUTERLINKPORTONTIER0`
            *
              :attr:`LogicalRouterPort.RESOURCE_TYPE_LOGICALROUTERLINKPORTONTIER1`
            * :attr:`LogicalRouterPort.RESOURCE_TYPE_LOGICALROUTERLOOPBACKPORT`
            * :attr:`LogicalRouterPort.RESOURCE_TYPE_LOGICALROUTERIPTUNNELPORT`
            *
              :attr:`LogicalRouterPort.RESOURCE_TYPE_LOGICALROUTERCENTRALIZEDSERVICEPORT`
            
            LogicalRouterUpLinkPort is allowed only on TIER0 logical router. It
            is the north facing port of the logical router.
            LogicalRouterLinkPortOnTIER0 is allowed only on TIER0 logical
            router. This is the port where the LogicalRouterLinkPortOnTIER1 of
            TIER1 logical router connects to. LogicalRouterLinkPortOnTIER1 is
            allowed only on TIER1 logical router. This is the port using which
            the user connected to TIER1 logical router for upwards connectivity
            via TIER0 logical router. Connect this port to the
            LogicalRouterLinkPortOnTIER0 of the TIER0 logical router.
            LogicalRouterDownLinkPort is for the connected subnets on the
            logical router. LogicalRouterLoopbackPort is a loopback port for
            logical router component which is placed on chosen edge cluster
            member. LogicalRouterIPTunnelPort is a IPSec VPN tunnel port
            created on logical router when route based VPN session configured.
            LogicalRouterCentralizedServicePort is allowed only on
            Active/Standby TIER0 and TIER1 logical router. Port can be
            connected to VLAN or overlay logical switch. Unlike downlink port
            it does not participate in distributed routing and hosted on all
            edge cluster members associated with logical router. Stateful
            services can be applied on this port.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  logical_router_id: :class:`str` or ``None``
        :param logical_router_id: Identifier for logical router on which this port is created
        :type  service_bindings: :class:`list` of :class:`ServiceBinding` or ``None``
        :param service_bindings: Service Bindings
        """
        self.enable_netx = enable_netx
        self.linked_logical_switch_port_id = linked_logical_switch_port_id
        self.mtu = mtu
        self.ndra_profile_id = ndra_profile_id
        self.subnets = subnets
        self.urpf_mode = urpf_mode
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        self.logical_router_id = logical_router_id
        self.service_bindings = service_bindings
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

LogicalRouterCentralizedServicePort._set_binding_type(type.StructType(
    'com.vmware.nsx.model.logical_router_centralized_service_port', {
        'enable_netx': type.OptionalType(type.BooleanType()),
        'linked_logical_switch_port_id': type.OptionalType(type.ReferenceType(__name__, 'ResourceReference')),
        'mtu': type.OptionalType(type.IntegerType()),
        'ndra_profile_id': type.OptionalType(type.StringType()),
        'subnets': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IPSubnet'))),
        'urpf_mode': type.OptionalType(type.StringType()),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'logical_router_id': type.OptionalType(type.StringType()),
        'service_bindings': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ServiceBinding'))),
    },
    LogicalRouterCentralizedServicePort,
    False,
    None))



class LogicalRouterConfig(VapiStruct):
    """
    Logical router configuration parameters.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'external_transit_networks': 'external_transit_networks',
                            'ha_vip_configs': 'ha_vip_configs',
                            'internal_transit_network': 'internal_transit_network',
                            'transport_zone_id': 'transport_zone_id',
                            }

    def __init__(self,
                 external_transit_networks=None,
                 ha_vip_configs=None,
                 internal_transit_network=None,
                 transport_zone_id=None,
                ):
        """
        :type  external_transit_networks: :class:`list` of :class:`str` or ``None``
        :param external_transit_networks: CIDR block defining addresses for Tier0 to Tier1 links. If the
            value for this field is not provided, then it will be considered as
            default IPv4 CIDR \"100.64.0.0/16\" format: ip-cidr-block
        :type  ha_vip_configs: :class:`list` of :class:`HaVipConfig` or ``None``
        :param ha_vip_configs: This configuration can be defined only for Active-Standby
            LogicalRouter to provide | redundancy. For mulitple uplink ports,
            multiple HaVipConfigs must be defined | and each config will pair
            exactly two uplink ports. The VIP will move and will | always be
            owned by the Active node. Note - when HaVipConfig[s] are defined, |
            configuring dynamic-routing is disallowed.
        :type  internal_transit_network: :class:`str` or ``None``
        :param internal_transit_network: CIDR block defining service router to distributed router links. If
            the value for this field is not provided, then it will be
            considered as default IPv4 CIDR- \"169.254.0.0/28\" for logical
            router with ACTIVE_STANDBY HA mode \"169.254.0.0/24\" for logical
            router with ACTIVE_ACTIVE HA mode format: ipv4-cidr-block
        :type  transport_zone_id: :class:`str` or ``None``
        :param transport_zone_id: Transport zone of the logical router. If specified then all
            downlink switches should belong to this transport zone and an error
            will be thrown if transport zone of the downlink switch doesn't
            match with this transport zone. All internal and external transit
            switches will be created in this transport zone.
        """
        self.external_transit_networks = external_transit_networks
        self.ha_vip_configs = ha_vip_configs
        self.internal_transit_network = internal_transit_network
        self.transport_zone_id = transport_zone_id
        VapiStruct.__init__(self)


LogicalRouterConfig._set_binding_type(type.StructType(
    'com.vmware.nsx.model.logical_router_config', {
        'external_transit_networks': type.OptionalType(type.ListType(type.StringType())),
        'ha_vip_configs': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'HaVipConfig'))),
        'internal_transit_network': type.OptionalType(type.StringType()),
        'transport_zone_id': type.OptionalType(type.StringType()),
    },
    LogicalRouterConfig,
    False,
    None))



class LogicalRouterDownLinkPort(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LogicalRouterDownLinkPort"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    URPF_MODE_NONE = "NONE"
    """


    """
    URPF_MODE_STRICT = "STRICT"
    """


    """



    _canonical_to_pep_names = {
                            'enable_multicast': 'enable_multicast',
                            'linked_logical_switch_port_id': 'linked_logical_switch_port_id',
                            'mac_address': 'mac_address',
                            'ndra_profile_id': 'ndra_profile_id',
                            'routing_policies': 'routing_policies',
                            'subnets': 'subnets',
                            'urpf_mode': 'urpf_mode',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'logical_router_id': 'logical_router_id',
                            'service_bindings': 'service_bindings',
                            }

    def __init__(self,
                 enable_multicast=None,
                 linked_logical_switch_port_id=None,
                 mac_address=None,
                 ndra_profile_id=None,
                 routing_policies=None,
                 subnets=None,
                 urpf_mode=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='LogicalRouterDownLinkPort',
                 tags=None,
                 logical_router_id=None,
                 service_bindings=None,
                ):
        """
        :type  enable_multicast: :class:`bool` or ``None``
        :param enable_multicast: If this flag is set to true - it will enable multicast on the
            downlink interface. If this flag is set to false - it will disable
            multicast on the downlink interface. This is supported only on
            Tier0 downlinks. Default value for Tier0 downlink will be true.
        :type  linked_logical_switch_port_id: :class:`ResourceReference` or ``None``
        :param linked_logical_switch_port_id: Reference to the logical switch port to connect to
        :type  mac_address: :class:`str` or ``None``
        :param mac_address: MAC address
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  ndra_profile_id: :class:`str` or ``None``
        :param ndra_profile_id: Identifier of Neighbor Discovery Router Advertisement profile
            associated with port. When NDRA profile id is associated at both
            the port level and logical router level, the profile id specified
            at port level takes the precedence.
        :type  routing_policies: :class:`list` of :class:`RoutingPolicy` or ``None``
        :param routing_policies: Routing policies used to specify how the traffic, which matches the
            policy routes, will be processed.
        :type  subnets: :class:`list` of :class:`IPSubnet` or ``None``
        :param subnets: Logical router port subnets
        :type  urpf_mode: :class:`str` or ``None``
        :param urpf_mode: Possible values are: 
            
            * :attr:`LogicalRouterDownLinkPort.URPF_MODE_NONE`
            * :attr:`LogicalRouterDownLinkPort.URPF_MODE_STRICT`
            
             Unicast Reverse Path Forwarding mode
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`LogicalRouterPort.RESOURCE_TYPE_LOGICALROUTERUPLINKPORT`
            * :attr:`LogicalRouterPort.RESOURCE_TYPE_LOGICALROUTERDOWNLINKPORT`
            *
              :attr:`LogicalRouterPort.RESOURCE_TYPE_LOGICALROUTERLINKPORTONTIER0`
            *
              :attr:`LogicalRouterPort.RESOURCE_TYPE_LOGICALROUTERLINKPORTONTIER1`
            * :attr:`LogicalRouterPort.RESOURCE_TYPE_LOGICALROUTERLOOPBACKPORT`
            * :attr:`LogicalRouterPort.RESOURCE_TYPE_LOGICALROUTERIPTUNNELPORT`
            *
              :attr:`LogicalRouterPort.RESOURCE_TYPE_LOGICALROUTERCENTRALIZEDSERVICEPORT`
            
            LogicalRouterUpLinkPort is allowed only on TIER0 logical router. It
            is the north facing port of the logical router.
            LogicalRouterLinkPortOnTIER0 is allowed only on TIER0 logical
            router. This is the port where the LogicalRouterLinkPortOnTIER1 of
            TIER1 logical router connects to. LogicalRouterLinkPortOnTIER1 is
            allowed only on TIER1 logical router. This is the port using which
            the user connected to TIER1 logical router for upwards connectivity
            via TIER0 logical router. Connect this port to the
            LogicalRouterLinkPortOnTIER0 of the TIER0 logical router.
            LogicalRouterDownLinkPort is for the connected subnets on the
            logical router. LogicalRouterLoopbackPort is a loopback port for
            logical router component which is placed on chosen edge cluster
            member. LogicalRouterIPTunnelPort is a IPSec VPN tunnel port
            created on logical router when route based VPN session configured.
            LogicalRouterCentralizedServicePort is allowed only on
            Active/Standby TIER0 and TIER1 logical router. Port can be
            connected to VLAN or overlay logical switch. Unlike downlink port
            it does not participate in distributed routing and hosted on all
            edge cluster members associated with logical router. Stateful
            services can be applied on this port.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  logical_router_id: :class:`str` or ``None``
        :param logical_router_id: Identifier for logical router on which this port is created
        :type  service_bindings: :class:`list` of :class:`ServiceBinding` or ``None``
        :param service_bindings: Service Bindings
        """
        self.enable_multicast = enable_multicast
        self.linked_logical_switch_port_id = linked_logical_switch_port_id
        self.mac_address = mac_address
        self.ndra_profile_id = ndra_profile_id
        self.routing_policies = routing_policies
        self.subnets = subnets
        self.urpf_mode = urpf_mode
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        self.logical_router_id = logical_router_id
        self.service_bindings = service_bindings
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

LogicalRouterDownLinkPort._set_binding_type(type.StructType(
    'com.vmware.nsx.model.logical_router_down_link_port', {
        'enable_multicast': type.OptionalType(type.BooleanType()),
        'linked_logical_switch_port_id': type.OptionalType(type.ReferenceType(__name__, 'ResourceReference')),
        'mac_address': type.OptionalType(type.StringType()),
        'ndra_profile_id': type.OptionalType(type.StringType()),
        'routing_policies': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'RoutingPolicy'))),
        'subnets': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IPSubnet'))),
        'urpf_mode': type.OptionalType(type.StringType()),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'logical_router_id': type.OptionalType(type.StringType()),
        'service_bindings': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ServiceBinding'))),
    },
    LogicalRouterDownLinkPort,
    False,
    None))



class LogicalRouterIPTunnelPort(VapiStruct):
    """
    Logical router IP tunnel port.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LogicalRouterIPTunnelPort"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    ADMIN_STATE_UP = "UP"
    """


    """
    ADMIN_STATE_DOWN = "DOWN"
    """


    """



    _canonical_to_pep_names = {
                            'admin_state': 'admin_state',
                            'subnets': 'subnets',
                            'vpn_session_id': 'vpn_session_id',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'logical_router_id': 'logical_router_id',
                            'service_bindings': 'service_bindings',
                            }

    def __init__(self,
                 admin_state=None,
                 subnets=None,
                 vpn_session_id=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='LogicalRouterIPTunnelPort',
                 tags=None,
                 logical_router_id=None,
                 service_bindings=None,
                ):
        """
        :type  admin_state: :class:`str` or ``None``
        :param admin_state: Possible values are: 
            
            * :attr:`LogicalRouterIPTunnelPort.ADMIN_STATE_UP`
            * :attr:`LogicalRouterIPTunnelPort.ADMIN_STATE_DOWN`
            
             Admin state of port.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  subnets: :class:`list` of :class:`IPSubnet` or ``None``
        :param subnets: Tunnel port subnets.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  vpn_session_id: :class:`str` or ``None``
        :param vpn_session_id: Associated VPN session identifier.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`LogicalRouterPort.RESOURCE_TYPE_LOGICALROUTERUPLINKPORT`
            * :attr:`LogicalRouterPort.RESOURCE_TYPE_LOGICALROUTERDOWNLINKPORT`
            *
              :attr:`LogicalRouterPort.RESOURCE_TYPE_LOGICALROUTERLINKPORTONTIER0`
            *
              :attr:`LogicalRouterPort.RESOURCE_TYPE_LOGICALROUTERLINKPORTONTIER1`
            * :attr:`LogicalRouterPort.RESOURCE_TYPE_LOGICALROUTERLOOPBACKPORT`
            * :attr:`LogicalRouterPort.RESOURCE_TYPE_LOGICALROUTERIPTUNNELPORT`
            *
              :attr:`LogicalRouterPort.RESOURCE_TYPE_LOGICALROUTERCENTRALIZEDSERVICEPORT`
            
            LogicalRouterUpLinkPort is allowed only on TIER0 logical router. It
            is the north facing port of the logical router.
            LogicalRouterLinkPortOnTIER0 is allowed only on TIER0 logical
            router. This is the port where the LogicalRouterLinkPortOnTIER1 of
            TIER1 logical router connects to. LogicalRouterLinkPortOnTIER1 is
            allowed only on TIER1 logical router. This is the port using which
            the user connected to TIER1 logical router for upwards connectivity
            via TIER0 logical router. Connect this port to the
            LogicalRouterLinkPortOnTIER0 of the TIER0 logical router.
            LogicalRouterDownLinkPort is for the connected subnets on the
            logical router. LogicalRouterLoopbackPort is a loopback port for
            logical router component which is placed on chosen edge cluster
            member. LogicalRouterIPTunnelPort is a IPSec VPN tunnel port
            created on logical router when route based VPN session configured.
            LogicalRouterCentralizedServicePort is allowed only on
            Active/Standby TIER0 and TIER1 logical router. Port can be
            connected to VLAN or overlay logical switch. Unlike downlink port
            it does not participate in distributed routing and hosted on all
            edge cluster members associated with logical router. Stateful
            services can be applied on this port.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  logical_router_id: :class:`str` or ``None``
        :param logical_router_id: Identifier for logical router on which this port is created
        :type  service_bindings: :class:`list` of :class:`ServiceBinding` or ``None``
        :param service_bindings: Service Bindings
        """
        self.admin_state = admin_state
        self.subnets = subnets
        self.vpn_session_id = vpn_session_id
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        self.logical_router_id = logical_router_id
        self.service_bindings = service_bindings
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

LogicalRouterIPTunnelPort._set_binding_type(type.StructType(
    'com.vmware.nsx.model.logical_router_IP_tunnel_port', {
        'admin_state': type.OptionalType(type.StringType()),
        'subnets': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IPSubnet'))),
        'vpn_session_id': type.OptionalType(type.StringType()),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'logical_router_id': type.OptionalType(type.StringType()),
        'service_bindings': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ServiceBinding'))),
    },
    LogicalRouterIPTunnelPort,
    False,
    None))



class LogicalRouterLinkPortOnTIER0(VapiStruct):
    """
    This port can be configured only on a TIER0 LogicalRouter. Create an empty
    port to generate an id. Use this id in the linked_logical_router_port_id on
    LogicalRouterLinkPortOnTIER1 on TIER1 logical router.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LogicalRouterLinkPortOnTIER0"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'linked_logical_router_port_id': 'linked_logical_router_port_id',
                            'mac_address': 'mac_address',
                            'subnets': 'subnets',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'logical_router_id': 'logical_router_id',
                            'service_bindings': 'service_bindings',
                            }

    def __init__(self,
                 linked_logical_router_port_id=None,
                 mac_address=None,
                 subnets=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='LogicalRouterLinkPortOnTIER0',
                 tags=None,
                 logical_router_id=None,
                 service_bindings=None,
                ):
        """
        :type  linked_logical_router_port_id: :class:`str` or ``None``
        :param linked_logical_router_port_id: Identifier of connected LogicalRouterLinkPortOnTIER1 of TIER1
            logical router
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  mac_address: :class:`str` or ``None``
        :param mac_address: MAC address
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  subnets: :class:`list` of :class:`IPSubnet` or ``None``
        :param subnets: Logical router port subnets
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`LogicalRouterPort.RESOURCE_TYPE_LOGICALROUTERUPLINKPORT`
            * :attr:`LogicalRouterPort.RESOURCE_TYPE_LOGICALROUTERDOWNLINKPORT`
            *
              :attr:`LogicalRouterPort.RESOURCE_TYPE_LOGICALROUTERLINKPORTONTIER0`
            *
              :attr:`LogicalRouterPort.RESOURCE_TYPE_LOGICALROUTERLINKPORTONTIER1`
            * :attr:`LogicalRouterPort.RESOURCE_TYPE_LOGICALROUTERLOOPBACKPORT`
            * :attr:`LogicalRouterPort.RESOURCE_TYPE_LOGICALROUTERIPTUNNELPORT`
            *
              :attr:`LogicalRouterPort.RESOURCE_TYPE_LOGICALROUTERCENTRALIZEDSERVICEPORT`
            
            LogicalRouterUpLinkPort is allowed only on TIER0 logical router. It
            is the north facing port of the logical router.
            LogicalRouterLinkPortOnTIER0 is allowed only on TIER0 logical
            router. This is the port where the LogicalRouterLinkPortOnTIER1 of
            TIER1 logical router connects to. LogicalRouterLinkPortOnTIER1 is
            allowed only on TIER1 logical router. This is the port using which
            the user connected to TIER1 logical router for upwards connectivity
            via TIER0 logical router. Connect this port to the
            LogicalRouterLinkPortOnTIER0 of the TIER0 logical router.
            LogicalRouterDownLinkPort is for the connected subnets on the
            logical router. LogicalRouterLoopbackPort is a loopback port for
            logical router component which is placed on chosen edge cluster
            member. LogicalRouterIPTunnelPort is a IPSec VPN tunnel port
            created on logical router when route based VPN session configured.
            LogicalRouterCentralizedServicePort is allowed only on
            Active/Standby TIER0 and TIER1 logical router. Port can be
            connected to VLAN or overlay logical switch. Unlike downlink port
            it does not participate in distributed routing and hosted on all
            edge cluster members associated with logical router. Stateful
            services can be applied on this port.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  logical_router_id: :class:`str` or ``None``
        :param logical_router_id: Identifier for logical router on which this port is created
        :type  service_bindings: :class:`list` of :class:`ServiceBinding` or ``None``
        :param service_bindings: Service Bindings
        """
        self.linked_logical_router_port_id = linked_logical_router_port_id
        self.mac_address = mac_address
        self.subnets = subnets
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        self.logical_router_id = logical_router_id
        self.service_bindings = service_bindings
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

LogicalRouterLinkPortOnTIER0._set_binding_type(type.StructType(
    'com.vmware.nsx.model.logical_router_link_port_on_TIE_r0', {
        'linked_logical_router_port_id': type.OptionalType(type.StringType()),
        'mac_address': type.OptionalType(type.StringType()),
        'subnets': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IPSubnet'))),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'logical_router_id': type.OptionalType(type.StringType()),
        'service_bindings': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ServiceBinding'))),
    },
    LogicalRouterLinkPortOnTIER0,
    False,
    None))



class LogicalRouterLinkPortOnTIER1(VapiStruct):
    """
    This port can be configured only on a TIER1 LogicalRouter. Use the id of
    the LogicalRouterLinkPortOnTIER0 from TIER0 logical router to set the
    linked_logical_router_port_id on the port on TIER1 logical router.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LogicalRouterLinkPortOnTIER1"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'edge_cluster_member_index': 'edge_cluster_member_index',
                            'linked_logical_router_port_id': 'linked_logical_router_port_id',
                            'mac_address': 'mac_address',
                            'subnets': 'subnets',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'logical_router_id': 'logical_router_id',
                            'service_bindings': 'service_bindings',
                            }

    def __init__(self,
                 edge_cluster_member_index=None,
                 linked_logical_router_port_id=None,
                 mac_address=None,
                 subnets=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='LogicalRouterLinkPortOnTIER1',
                 tags=None,
                 logical_router_id=None,
                 service_bindings=None,
                ):
        """
        :type  edge_cluster_member_index: :class:`list` of :class:`long` or ``None``
        :param edge_cluster_member_index: Please use logical router API to pass edge cluster members indexes
            manually. format: int64
        :type  linked_logical_router_port_id: :class:`ResourceReference` or ``None``
        :param linked_logical_router_port_id: Reference of LogicalRouterLinkPortOnTIER0 of TIER0 logical router
            to connect this TIER1 logical router outwards.
        :type  mac_address: :class:`str` or ``None``
        :param mac_address: MAC address
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  subnets: :class:`list` of :class:`IPSubnet` or ``None``
        :param subnets: Logical router port subnets
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`LogicalRouterPort.RESOURCE_TYPE_LOGICALROUTERUPLINKPORT`
            * :attr:`LogicalRouterPort.RESOURCE_TYPE_LOGICALROUTERDOWNLINKPORT`
            *
              :attr:`LogicalRouterPort.RESOURCE_TYPE_LOGICALROUTERLINKPORTONTIER0`
            *
              :attr:`LogicalRouterPort.RESOURCE_TYPE_LOGICALROUTERLINKPORTONTIER1`
            * :attr:`LogicalRouterPort.RESOURCE_TYPE_LOGICALROUTERLOOPBACKPORT`
            * :attr:`LogicalRouterPort.RESOURCE_TYPE_LOGICALROUTERIPTUNNELPORT`
            *
              :attr:`LogicalRouterPort.RESOURCE_TYPE_LOGICALROUTERCENTRALIZEDSERVICEPORT`
            
            LogicalRouterUpLinkPort is allowed only on TIER0 logical router. It
            is the north facing port of the logical router.
            LogicalRouterLinkPortOnTIER0 is allowed only on TIER0 logical
            router. This is the port where the LogicalRouterLinkPortOnTIER1 of
            TIER1 logical router connects to. LogicalRouterLinkPortOnTIER1 is
            allowed only on TIER1 logical router. This is the port using which
            the user connected to TIER1 logical router for upwards connectivity
            via TIER0 logical router. Connect this port to the
            LogicalRouterLinkPortOnTIER0 of the TIER0 logical router.
            LogicalRouterDownLinkPort is for the connected subnets on the
            logical router. LogicalRouterLoopbackPort is a loopback port for
            logical router component which is placed on chosen edge cluster
            member. LogicalRouterIPTunnelPort is a IPSec VPN tunnel port
            created on logical router when route based VPN session configured.
            LogicalRouterCentralizedServicePort is allowed only on
            Active/Standby TIER0 and TIER1 logical router. Port can be
            connected to VLAN or overlay logical switch. Unlike downlink port
            it does not participate in distributed routing and hosted on all
            edge cluster members associated with logical router. Stateful
            services can be applied on this port.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  logical_router_id: :class:`str` or ``None``
        :param logical_router_id: Identifier for logical router on which this port is created
        :type  service_bindings: :class:`list` of :class:`ServiceBinding` or ``None``
        :param service_bindings: Service Bindings
        """
        self.edge_cluster_member_index = edge_cluster_member_index
        self.linked_logical_router_port_id = linked_logical_router_port_id
        self.mac_address = mac_address
        self.subnets = subnets
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        self.logical_router_id = logical_router_id
        self.service_bindings = service_bindings
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

LogicalRouterLinkPortOnTIER1._set_binding_type(type.StructType(
    'com.vmware.nsx.model.logical_router_link_port_on_TIE_r1', {
        'edge_cluster_member_index': type.OptionalType(type.ListType(type.IntegerType())),
        'linked_logical_router_port_id': type.OptionalType(type.ReferenceType(__name__, 'ResourceReference')),
        'mac_address': type.OptionalType(type.StringType()),
        'subnets': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IPSubnet'))),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'logical_router_id': type.OptionalType(type.StringType()),
        'service_bindings': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ServiceBinding'))),
    },
    LogicalRouterLinkPortOnTIER1,
    False,
    None))



class LogicalRouterListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`LogicalRouter` or ``None``
        :param results: Logical router list results
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


LogicalRouterListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.logical_router_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'LogicalRouter'))),
    },
    LogicalRouterListResult,
    False,
    None))



class LogicalRouterLoopbackPort(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LogicalRouterLoopbackPort"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'edge_cluster_member_index': 'edge_cluster_member_index',
                            'subnets': 'subnets',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'logical_router_id': 'logical_router_id',
                            'service_bindings': 'service_bindings',
                            }

    def __init__(self,
                 edge_cluster_member_index=None,
                 subnets=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='LogicalRouterLoopbackPort',
                 tags=None,
                 logical_router_id=None,
                 service_bindings=None,
                ):
        """
        :type  edge_cluster_member_index: :class:`list` of :class:`long` or ``None``
        :param edge_cluster_member_index: Member index of the edge node on the cluster format: int64
        :type  subnets: :class:`list` of :class:`IPSubnet` or ``None``
        :param subnets: Loopback port subnets
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`LogicalRouterPort.RESOURCE_TYPE_LOGICALROUTERUPLINKPORT`
            * :attr:`LogicalRouterPort.RESOURCE_TYPE_LOGICALROUTERDOWNLINKPORT`
            *
              :attr:`LogicalRouterPort.RESOURCE_TYPE_LOGICALROUTERLINKPORTONTIER0`
            *
              :attr:`LogicalRouterPort.RESOURCE_TYPE_LOGICALROUTERLINKPORTONTIER1`
            * :attr:`LogicalRouterPort.RESOURCE_TYPE_LOGICALROUTERLOOPBACKPORT`
            * :attr:`LogicalRouterPort.RESOURCE_TYPE_LOGICALROUTERIPTUNNELPORT`
            *
              :attr:`LogicalRouterPort.RESOURCE_TYPE_LOGICALROUTERCENTRALIZEDSERVICEPORT`
            
            LogicalRouterUpLinkPort is allowed only on TIER0 logical router. It
            is the north facing port of the logical router.
            LogicalRouterLinkPortOnTIER0 is allowed only on TIER0 logical
            router. This is the port where the LogicalRouterLinkPortOnTIER1 of
            TIER1 logical router connects to. LogicalRouterLinkPortOnTIER1 is
            allowed only on TIER1 logical router. This is the port using which
            the user connected to TIER1 logical router for upwards connectivity
            via TIER0 logical router. Connect this port to the
            LogicalRouterLinkPortOnTIER0 of the TIER0 logical router.
            LogicalRouterDownLinkPort is for the connected subnets on the
            logical router. LogicalRouterLoopbackPort is a loopback port for
            logical router component which is placed on chosen edge cluster
            member. LogicalRouterIPTunnelPort is a IPSec VPN tunnel port
            created on logical router when route based VPN session configured.
            LogicalRouterCentralizedServicePort is allowed only on
            Active/Standby TIER0 and TIER1 logical router. Port can be
            connected to VLAN or overlay logical switch. Unlike downlink port
            it does not participate in distributed routing and hosted on all
            edge cluster members associated with logical router. Stateful
            services can be applied on this port.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  logical_router_id: :class:`str` or ``None``
        :param logical_router_id: Identifier for logical router on which this port is created
        :type  service_bindings: :class:`list` of :class:`ServiceBinding` or ``None``
        :param service_bindings: Service Bindings
        """
        self.edge_cluster_member_index = edge_cluster_member_index
        self.subnets = subnets
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        self.logical_router_id = logical_router_id
        self.service_bindings = service_bindings
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

LogicalRouterLoopbackPort._set_binding_type(type.StructType(
    'com.vmware.nsx.model.logical_router_loopback_port', {
        'edge_cluster_member_index': type.OptionalType(type.ListType(type.IntegerType())),
        'subnets': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IPSubnet'))),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'logical_router_id': type.OptionalType(type.StringType()),
        'service_bindings': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ServiceBinding'))),
    },
    LogicalRouterLoopbackPort,
    False,
    None))



class LogicalRouterPort(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LogicalRouterPort"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    RESOURCE_TYPE_LOGICALROUTERUPLINKPORT = "LogicalRouterUpLinkPort"
    """


    """
    RESOURCE_TYPE_LOGICALROUTERDOWNLINKPORT = "LogicalRouterDownLinkPort"
    """


    """
    RESOURCE_TYPE_LOGICALROUTERLINKPORTONTIER0 = "LogicalRouterLinkPortOnTIER0"
    """


    """
    RESOURCE_TYPE_LOGICALROUTERLINKPORTONTIER1 = "LogicalRouterLinkPortOnTIER1"
    """


    """
    RESOURCE_TYPE_LOGICALROUTERLOOPBACKPORT = "LogicalRouterLoopbackPort"
    """


    """
    RESOURCE_TYPE_LOGICALROUTERIPTUNNELPORT = "LogicalRouterIPTunnelPort"
    """


    """
    RESOURCE_TYPE_LOGICALROUTERCENTRALIZEDSERVICEPORT = "LogicalRouterCentralizedServicePort"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'logical_router_id': 'logical_router_id',
                            'service_bindings': 'service_bindings',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='LogicalRouterPort',
                 tags=None,
                 logical_router_id=None,
                 service_bindings=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`LogicalRouterPort.RESOURCE_TYPE_LOGICALROUTERUPLINKPORT`
            * :attr:`LogicalRouterPort.RESOURCE_TYPE_LOGICALROUTERDOWNLINKPORT`
            *
              :attr:`LogicalRouterPort.RESOURCE_TYPE_LOGICALROUTERLINKPORTONTIER0`
            *
              :attr:`LogicalRouterPort.RESOURCE_TYPE_LOGICALROUTERLINKPORTONTIER1`
            * :attr:`LogicalRouterPort.RESOURCE_TYPE_LOGICALROUTERLOOPBACKPORT`
            * :attr:`LogicalRouterPort.RESOURCE_TYPE_LOGICALROUTERIPTUNNELPORT`
            *
              :attr:`LogicalRouterPort.RESOURCE_TYPE_LOGICALROUTERCENTRALIZEDSERVICEPORT`
            
            LogicalRouterUpLinkPort is allowed only on TIER0 logical router. It
            is the north facing port of the logical router.
            LogicalRouterLinkPortOnTIER0 is allowed only on TIER0 logical
            router. This is the port where the LogicalRouterLinkPortOnTIER1 of
            TIER1 logical router connects to. LogicalRouterLinkPortOnTIER1 is
            allowed only on TIER1 logical router. This is the port using which
            the user connected to TIER1 logical router for upwards connectivity
            via TIER0 logical router. Connect this port to the
            LogicalRouterLinkPortOnTIER0 of the TIER0 logical router.
            LogicalRouterDownLinkPort is for the connected subnets on the
            logical router. LogicalRouterLoopbackPort is a loopback port for
            logical router component which is placed on chosen edge cluster
            member. LogicalRouterIPTunnelPort is a IPSec VPN tunnel port
            created on logical router when route based VPN session configured.
            LogicalRouterCentralizedServicePort is allowed only on
            Active/Standby TIER0 and TIER1 logical router. Port can be
            connected to VLAN or overlay logical switch. Unlike downlink port
            it does not participate in distributed routing and hosted on all
            edge cluster members associated with logical router. Stateful
            services can be applied on this port.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  logical_router_id: :class:`str` or ``None``
        :param logical_router_id: Identifier for logical router on which this port is created
        :type  service_bindings: :class:`list` of :class:`ServiceBinding` or ``None``
        :param service_bindings: Service Bindings
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        self.logical_router_id = logical_router_id
        self.service_bindings = service_bindings
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

LogicalRouterPort._set_binding_type(type.StructType(
    'com.vmware.nsx.model.logical_router_port', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'logical_router_id': type.OptionalType(type.StringType()),
        'service_bindings': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ServiceBinding'))),
    },
    LogicalRouterPort,
    False,
    None))



class LogicalRouterPortArpCsvRecord(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'ip': 'ip',
                            'mac_address': 'mac_address',
                            }

    def __init__(self,
                 ip=None,
                 mac_address=None,
                ):
        """
        :type  ip: :class:`str` or ``None``
        :param ip: The IP address format: ip
        :type  mac_address: :class:`str` or ``None``
        :param mac_address: The MAC address
        """
        self.ip = ip
        self.mac_address = mac_address
        VapiStruct.__init__(self)


LogicalRouterPortArpCsvRecord._set_binding_type(type.StructType(
    'com.vmware.nsx.model.logical_router_port_arp_csv_record', {
        'ip': type.OptionalType(type.StringType()),
        'mac_address': type.OptionalType(type.StringType()),
    },
    LogicalRouterPortArpCsvRecord,
    False,
    None))



class LogicalRouterPortArpEntry(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'ip': 'ip',
                            'mac_address': 'mac_address',
                            }

    def __init__(self,
                 ip=None,
                 mac_address=None,
                ):
        """
        :type  ip: :class:`str` or ``None``
        :param ip: The IP address format: ip
        :type  mac_address: :class:`str` or ``None``
        :param mac_address: The MAC address
        """
        self.ip = ip
        self.mac_address = mac_address
        VapiStruct.__init__(self)


LogicalRouterPortArpEntry._set_binding_type(type.StructType(
    'com.vmware.nsx.model.logical_router_port_arp_entry', {
        'ip': type.OptionalType(type.StringType()),
        'mac_address': type.OptionalType(type.StringType()),
    },
    LogicalRouterPortArpEntry,
    False,
    None))



class LogicalRouterPortArpTable(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'last_update_timestamp': 'last_update_timestamp',
                            'logical_router_port_id': 'logical_router_port_id',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 last_update_timestamp=None,
                 logical_router_port_id=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_update_timestamp: :class:`long` or ``None``
        :param last_update_timestamp: Timestamp when the data was last updated; unset if data source has
            never updated the data. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  logical_router_port_id: :class:`str` or ``None``
        :param logical_router_port_id: The ID of the logical router port
        :type  results: :class:`list` of :class:`LogicalRouterPortArpEntry` or ``None``
        :param results: 
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.last_update_timestamp = last_update_timestamp
        self.logical_router_port_id = logical_router_port_id
        self.results = results
        VapiStruct.__init__(self)


LogicalRouterPortArpTable._set_binding_type(type.StructType(
    'com.vmware.nsx.model.logical_router_port_arp_table', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'last_update_timestamp': type.OptionalType(type.IntegerType()),
        'logical_router_port_id': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'LogicalRouterPortArpEntry'))),
    },
    LogicalRouterPortArpTable,
    False,
    None))



class LogicalRouterPortArpTableInCsvFormat(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'file_name': 'file_name',
                            'last_update_timestamp': 'last_update_timestamp',
                            'results': 'results',
                            }

    def __init__(self,
                 file_name=None,
                 last_update_timestamp=None,
                 results=None,
                ):
        """
        :type  file_name: :class:`str` or ``None``
        :param file_name: File name set by HTTP server if API returns CSV result as a file.
        :type  last_update_timestamp: :class:`long` or ``None``
        :param last_update_timestamp: Timestamp when the data was last updated; unset if data source has
            never updated the data. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`LogicalRouterPortArpCsvRecord` or ``None``
        :param results: 
        """
        self.file_name = file_name
        self.last_update_timestamp = last_update_timestamp
        self.results = results
        VapiStruct.__init__(self)


LogicalRouterPortArpTableInCsvFormat._set_binding_type(type.StructType(
    'com.vmware.nsx.model.logical_router_port_arp_table_in_csv_format', {
        'file_name': type.OptionalType(type.StringType()),
        'last_update_timestamp': type.OptionalType(type.IntegerType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'LogicalRouterPortArpCsvRecord'))),
    },
    LogicalRouterPortArpTableInCsvFormat,
    False,
    None))



class LogicalRouterPortCounters(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'blocked_packets': 'blocked_packets',
                            'dad_dropped_packets': 'dad_dropped_packets',
                            'destination_unsupported_dropped_packets': 'destination_unsupported_dropped_packets',
                            'dropped_packets': 'dropped_packets',
                            'firewall_dropped_packets': 'firewall_dropped_packets',
                            'frag_needed_dropped_packets': 'frag_needed_dropped_packets',
                            'ipsec_dropped_packets': 'ipsec_dropped_packets',
                            'ipsec_no_sa_dropped_packets': 'ipsec_no_sa_dropped_packets',
                            'ipsec_no_vti_dropped_packets': 'ipsec_no_vti_dropped_packets',
                            'ipsec_pol_block_dropped_packets': 'ipsec_pol_block_dropped_packets',
                            'ipsec_pol_err_dropped_packets': 'ipsec_pol_err_dropped_packets',
                            'ipv6_dropped_packets': 'ipv6_dropped_packets',
                            'kni_dropped_packets': 'kni_dropped_packets',
                            'l4port_unsupported_dropped_packets': 'l4port_unsupported_dropped_packets',
                            'malformed_dropped_packets': 'malformed_dropped_packets',
                            'no_arp_dropped_packets': 'no_arp_dropped_packets',
                            'no_linked_dropped_packets': 'no_linked_dropped_packets',
                            'no_mem_dropped_packets': 'no_mem_dropped_packets',
                            'no_receiver_dropped_packets': 'no_receiver_dropped_packets',
                            'no_route_dropped_packets': 'no_route_dropped_packets',
                            'non_ip_dropped_packets': 'non_ip_dropped_packets',
                            'proto_unsupported_dropped_packets': 'proto_unsupported_dropped_packets',
                            'redirect_dropped_packets': 'redirect_dropped_packets',
                            'rpf_check_dropped_packets': 'rpf_check_dropped_packets',
                            'service_insert_dropped_packets': 'service_insert_dropped_packets',
                            'total_bytes': 'total_bytes',
                            'total_packets': 'total_packets',
                            'ttl_exceeded_dropped_packets': 'ttl_exceeded_dropped_packets',
                            }

    def __init__(self,
                 blocked_packets=None,
                 dad_dropped_packets=None,
                 destination_unsupported_dropped_packets=None,
                 dropped_packets=None,
                 firewall_dropped_packets=None,
                 frag_needed_dropped_packets=None,
                 ipsec_dropped_packets=None,
                 ipsec_no_sa_dropped_packets=None,
                 ipsec_no_vti_dropped_packets=None,
                 ipsec_pol_block_dropped_packets=None,
                 ipsec_pol_err_dropped_packets=None,
                 ipv6_dropped_packets=None,
                 kni_dropped_packets=None,
                 l4port_unsupported_dropped_packets=None,
                 malformed_dropped_packets=None,
                 no_arp_dropped_packets=None,
                 no_linked_dropped_packets=None,
                 no_mem_dropped_packets=None,
                 no_receiver_dropped_packets=None,
                 no_route_dropped_packets=None,
                 non_ip_dropped_packets=None,
                 proto_unsupported_dropped_packets=None,
                 redirect_dropped_packets=None,
                 rpf_check_dropped_packets=None,
                 service_insert_dropped_packets=None,
                 total_bytes=None,
                 total_packets=None,
                 ttl_exceeded_dropped_packets=None,
                ):
        """
        :type  blocked_packets: :class:`long` or ``None``
        :param blocked_packets: The total number of packets blocked. format: int64
        :type  dad_dropped_packets: :class:`long` or ``None``
        :param dad_dropped_packets: Number of duplicate address detected packets dropped. format: int64
        :type  destination_unsupported_dropped_packets: :class:`long` or ``None``
        :param destination_unsupported_dropped_packets: Number of packtes dropped as destination is not supported. format:
            int64
        :type  dropped_packets: :class:`long` or ``None``
        :param dropped_packets: The total number of packets dropped. format: int64
        :type  firewall_dropped_packets: :class:`long` or ``None``
        :param firewall_dropped_packets: Number of firewall packets dropped. format: int64
        :type  frag_needed_dropped_packets: :class:`long` or ``None``
        :param frag_needed_dropped_packets: Number of fragmentation needed packets dropped. format: int64
        :type  ipsec_dropped_packets: :class:`long` or ``None``
        :param ipsec_dropped_packets: Number of IPSec packets dropped format: int64
        :type  ipsec_no_sa_dropped_packets: :class:`long` or ``None``
        :param ipsec_no_sa_dropped_packets: Number of IPSec no security association packets dropped. format:
            int64
        :type  ipsec_no_vti_dropped_packets: :class:`long` or ``None``
        :param ipsec_no_vti_dropped_packets: Number of IPSec packets dropped as no VTI is present. format: int64
        :type  ipsec_pol_block_dropped_packets: :class:`long` or ``None``
        :param ipsec_pol_block_dropped_packets: Number of IPSec policy block packets dropped. format: int64
        :type  ipsec_pol_err_dropped_packets: :class:`long` or ``None``
        :param ipsec_pol_err_dropped_packets: Number of IPSec policy error packets dropped. format: int64
        :type  ipv6_dropped_packets: :class:`long` or ``None``
        :param ipv6_dropped_packets: Number of IPV6 packets dropped. format: int64
        :type  kni_dropped_packets: :class:`long` or ``None``
        :param kni_dropped_packets: Number of DPDK kernal NIC interface packets dropped. format: int64
        :type  l4port_unsupported_dropped_packets: :class:`long` or ``None``
        :param l4port_unsupported_dropped_packets: Number of packets dropped due to unsupported L4 port. format: int64
        :type  malformed_dropped_packets: :class:`long` or ``None``
        :param malformed_dropped_packets: Number of packtes dropped as they are malformed. format: int64
        :type  no_arp_dropped_packets: :class:`long` or ``None``
        :param no_arp_dropped_packets: Number of no ARP packets dropped. format: int64
        :type  no_linked_dropped_packets: :class:`long` or ``None``
        :param no_linked_dropped_packets: Number of packets dropped as no linked ports are present. format:
            int64
        :type  no_mem_dropped_packets: :class:`long` or ``None``
        :param no_mem_dropped_packets: Number of packets dropped due to insufficient memory. format: int64
        :type  no_receiver_dropped_packets: :class:`long` or ``None``
        :param no_receiver_dropped_packets: Number of packets dropped due to absence of receiver. format: int64
        :type  no_route_dropped_packets: :class:`long` or ``None``
        :param no_route_dropped_packets: The number of no route packets dropped format: int64
        :type  non_ip_dropped_packets: :class:`long` or ``None``
        :param non_ip_dropped_packets: Number of non IP packets dropped. format: int64
        :type  proto_unsupported_dropped_packets: :class:`long` or ``None``
        :param proto_unsupported_dropped_packets: Number of packets dropped as protocol is unsupported. format: int64
        :type  redirect_dropped_packets: :class:`long` or ``None``
        :param redirect_dropped_packets: Number of redirect packets dropped. format: int64
        :type  rpf_check_dropped_packets: :class:`long` or ``None``
        :param rpf_check_dropped_packets: Number of reverse-path forwarding check packets dropped. format:
            int64
        :type  service_insert_dropped_packets: :class:`long` or ``None``
        :param service_insert_dropped_packets: Number of service insert packets dropped. format: int64
        :type  total_bytes: :class:`long` or ``None``
        :param total_bytes: The total number of bytes transferred. format: int64
        :type  total_packets: :class:`long` or ``None``
        :param total_packets: The total number of packets transferred. format: int64
        :type  ttl_exceeded_dropped_packets: :class:`long` or ``None``
        :param ttl_exceeded_dropped_packets: Number of time to live exceeded packets dropped. format: int64
        """
        self.blocked_packets = blocked_packets
        self.dad_dropped_packets = dad_dropped_packets
        self.destination_unsupported_dropped_packets = destination_unsupported_dropped_packets
        self.dropped_packets = dropped_packets
        self.firewall_dropped_packets = firewall_dropped_packets
        self.frag_needed_dropped_packets = frag_needed_dropped_packets
        self.ipsec_dropped_packets = ipsec_dropped_packets
        self.ipsec_no_sa_dropped_packets = ipsec_no_sa_dropped_packets
        self.ipsec_no_vti_dropped_packets = ipsec_no_vti_dropped_packets
        self.ipsec_pol_block_dropped_packets = ipsec_pol_block_dropped_packets
        self.ipsec_pol_err_dropped_packets = ipsec_pol_err_dropped_packets
        self.ipv6_dropped_packets = ipv6_dropped_packets
        self.kni_dropped_packets = kni_dropped_packets
        self.l4port_unsupported_dropped_packets = l4port_unsupported_dropped_packets
        self.malformed_dropped_packets = malformed_dropped_packets
        self.no_arp_dropped_packets = no_arp_dropped_packets
        self.no_linked_dropped_packets = no_linked_dropped_packets
        self.no_mem_dropped_packets = no_mem_dropped_packets
        self.no_receiver_dropped_packets = no_receiver_dropped_packets
        self.no_route_dropped_packets = no_route_dropped_packets
        self.non_ip_dropped_packets = non_ip_dropped_packets
        self.proto_unsupported_dropped_packets = proto_unsupported_dropped_packets
        self.redirect_dropped_packets = redirect_dropped_packets
        self.rpf_check_dropped_packets = rpf_check_dropped_packets
        self.service_insert_dropped_packets = service_insert_dropped_packets
        self.total_bytes = total_bytes
        self.total_packets = total_packets
        self.ttl_exceeded_dropped_packets = ttl_exceeded_dropped_packets
        VapiStruct.__init__(self)


LogicalRouterPortCounters._set_binding_type(type.StructType(
    'com.vmware.nsx.model.logical_router_port_counters', {
        'blocked_packets': type.OptionalType(type.IntegerType()),
        'dad_dropped_packets': type.OptionalType(type.IntegerType()),
        'destination_unsupported_dropped_packets': type.OptionalType(type.IntegerType()),
        'dropped_packets': type.OptionalType(type.IntegerType()),
        'firewall_dropped_packets': type.OptionalType(type.IntegerType()),
        'frag_needed_dropped_packets': type.OptionalType(type.IntegerType()),
        'ipsec_dropped_packets': type.OptionalType(type.IntegerType()),
        'ipsec_no_sa_dropped_packets': type.OptionalType(type.IntegerType()),
        'ipsec_no_vti_dropped_packets': type.OptionalType(type.IntegerType()),
        'ipsec_pol_block_dropped_packets': type.OptionalType(type.IntegerType()),
        'ipsec_pol_err_dropped_packets': type.OptionalType(type.IntegerType()),
        'ipv6_dropped_packets': type.OptionalType(type.IntegerType()),
        'kni_dropped_packets': type.OptionalType(type.IntegerType()),
        'l4port_unsupported_dropped_packets': type.OptionalType(type.IntegerType()),
        'malformed_dropped_packets': type.OptionalType(type.IntegerType()),
        'no_arp_dropped_packets': type.OptionalType(type.IntegerType()),
        'no_linked_dropped_packets': type.OptionalType(type.IntegerType()),
        'no_mem_dropped_packets': type.OptionalType(type.IntegerType()),
        'no_receiver_dropped_packets': type.OptionalType(type.IntegerType()),
        'no_route_dropped_packets': type.OptionalType(type.IntegerType()),
        'non_ip_dropped_packets': type.OptionalType(type.IntegerType()),
        'proto_unsupported_dropped_packets': type.OptionalType(type.IntegerType()),
        'redirect_dropped_packets': type.OptionalType(type.IntegerType()),
        'rpf_check_dropped_packets': type.OptionalType(type.IntegerType()),
        'service_insert_dropped_packets': type.OptionalType(type.IntegerType()),
        'total_bytes': type.OptionalType(type.IntegerType()),
        'total_packets': type.OptionalType(type.IntegerType()),
        'ttl_exceeded_dropped_packets': type.OptionalType(type.IntegerType()),
    },
    LogicalRouterPortCounters,
    False,
    None))



class LogicalRouterPortListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param results: Logical router port list results
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`LogicalRouterPort`. When methods return a value of this
            class as a return value, the attribute will contain all the
            attributes defined in :class:`LogicalRouterPort`.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


LogicalRouterPortListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.logical_router_port_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'LogicalRouterPort')]))),
    },
    LogicalRouterPortListResult,
    False,
    None))



class LogicalRouterPortState(VapiStruct):
    """
    This holds the state of Logical Router Port. If there are errors in
    realizing LRP outside of MP, it gives details of the components and
    specific errors.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATE_PENDING = "pending"
    """


    """
    STATE_IN_PROGRESS = "in_progress"
    """


    """
    STATE_SUCCESS = "success"
    """


    """
    STATE_FAILED = "failed"
    """


    """
    STATE_PARTIAL_SUCCESS = "partial_success"
    """


    """
    STATE_ORPHANED = "orphaned"
    """


    """
    STATE_UNKNOWN = "unknown"
    """


    """
    STATE_ERROR = "error"
    """


    """
    STATE_IN_SYNC = "in_sync"
    """


    """
    STATE_NOT_AVAILABLE = "NOT_AVAILABLE"
    """


    """
    STATE_VM_DEPLOYMENT_QUEUED = "VM_DEPLOYMENT_QUEUED"
    """


    """
    STATE_VM_DEPLOYMENT_IN_PROGRESS = "VM_DEPLOYMENT_IN_PROGRESS"
    """


    """
    STATE_VM_DEPLOYMENT_FAILED = "VM_DEPLOYMENT_FAILED"
    """


    """
    STATE_VM_POWER_ON_IN_PROGRESS = "VM_POWER_ON_IN_PROGRESS"
    """


    """
    STATE_VM_POWER_ON_FAILED = "VM_POWER_ON_FAILED"
    """


    """
    STATE_REGISTRATION_PENDING = "REGISTRATION_PENDING"
    """


    """
    STATE_NODE_NOT_READY = "NODE_NOT_READY"
    """


    """
    STATE_NODE_READY = "NODE_READY"
    """


    """
    STATE_VM_POWER_OFF_IN_PROGRESS = "VM_POWER_OFF_IN_PROGRESS"
    """


    """
    STATE_VM_POWER_OFF_FAILED = "VM_POWER_OFF_FAILED"
    """


    """
    STATE_VM_UNDEPLOY_IN_PROGRESS = "VM_UNDEPLOY_IN_PROGRESS"
    """


    """
    STATE_VM_UNDEPLOY_FAILED = "VM_UNDEPLOY_FAILED"
    """


    """
    STATE_VM_UNDEPLOY_SUCCESSFUL = "VM_UNDEPLOY_SUCCESSFUL"
    """


    """
    STATE_EDGE_CONFIG_ERROR = "EDGE_CONFIG_ERROR"
    """


    """
    STATE_VM_DEPLOYMENT_RESTARTED = "VM_DEPLOYMENT_RESTARTED"
    """


    """
    STATE_REGISTRATION_FAILED = "REGISTRATION_FAILED"
    """


    """
    STATE_TRANSPORT_NODE_SYNC_PENDING = "TRANSPORT_NODE_SYNC_PENDING"
    """


    """
    STATE_TRANSPORT_NODE_CONFIGURATION_MISSING = "TRANSPORT_NODE_CONFIGURATION_MISSING"
    """


    """
    STATE_EDGE_HARDWARE_NOT_SUPPORTED = "EDGE_HARDWARE_NOT_SUPPORTED"
    """


    """
    STATE_MULTIPLE_OVERLAY_TZS_NOT_SUPPORTED = "MULTIPLE_OVERLAY_TZS_NOT_SUPPORTED"
    """


    """
    STATE_TN_OVERLAY_TZ_IN_USE_BY_EDGE_CLUSTER = "TN_OVERLAY_TZ_IN_USE_BY_EDGE_CLUSTER"
    """


    """
    STATE_TZ_ENDPOINTS_NOT_SPECIFIED = "TZ_ENDPOINTS_NOT_SPECIFIED"
    """


    """
    STATE_NO_PNIC_PREPARED_IN_EDGE = "NO_PNIC_PREPARED_IN_EDGE"
    """


    """
    STATE_APPLIANCE_INTERNAL_ERROR = "APPLIANCE_INTERNAL_ERROR"
    """


    """
    STATE_VTEP_DHCP_NOT_SUPPORTED = "VTEP_DHCP_NOT_SUPPORTED"
    """


    """
    STATE_UNSUPPORTED_HOST_SWITCH_PROFILE = "UNSUPPORTED_HOST_SWITCH_PROFILE"
    """


    """
    STATE_UPLINK_HOST_SWITCH_PROFILE_NOT_SPECIFIED = "UPLINK_HOST_SWITCH_PROFILE_NOT_SPECIFIED"
    """


    """
    STATE_HOSTSWITCH_PROFILE_NOT_FOUND = "HOSTSWITCH_PROFILE_NOT_FOUND"
    """


    """
    STATE_LLDP_SEND_ENABLED_NOT_SUPPORTED = "LLDP_SEND_ENABLED_NOT_SUPPORTED"
    """


    """
    STATE_UNSUPPORTED_NAMED_TEAMING_POLICY = "UNSUPPORTED_NAMED_TEAMING_POLICY"
    """


    """
    STATE_LBSRCID_NOT_SUPPORTED_FOR_EDGE_VM = "LBSRCID_NOT_SUPPORTED_FOR_EDGE_VM"
    """


    """
    STATE_LACP_NOT_SUPPORTED_FOR_EDGE_VM = "LACP_NOT_SUPPORTED_FOR_EDGE_VM"
    """


    """
    STATE_STANDBY_UPLINKS_NOT_SUPPORTED_FOR_EDGE_VM = "STANDBY_UPLINKS_NOT_SUPPORTED_FOR_EDGE_VM"
    """


    """
    STATE_MULTIPLE_ACTIVE_UPLINKS_NOT_SUPPORTED_FOR_EDGE = "MULTIPLE_ACTIVE_UPLINKS_NOT_SUPPORTED_FOR_EDGE"
    """


    """
    STATE_UNSUPPORTED_LACP_LB_ALGO_FOR_NODE = "UNSUPPORTED_LACP_LB_ALGO_FOR_NODE"
    """


    """
    STATE_EDGE_NODE_VERSION_NOT_SUPPORTED = "EDGE_NODE_VERSION_NOT_SUPPORTED"
    """


    """
    STATE_NO_PNIC_SPECIFIED_IN_TN = "NO_PNIC_SPECIFIED_IN_TN"
    """


    """
    STATE_INVALID_PNIC_DEVICE_NAME = "INVALID_PNIC_DEVICE_NAME"
    """


    """
    STATE_TRANSPORT_NODE_READY = "TRANSPORT_NODE_READY"
    """


    """
    STATE_VM_NETWORK_EDIT_PENDING = "VM_NETWORK_EDIT_PENDING"
    """


    """
    STATE_UNSUPPORTED_DEFAULT_TEAMING_POLICY = "UNSUPPORTED_DEFAULT_TEAMING_POLICY"
    """


    """
    STATE_MPA_DISCONNECTED = "MPA_DISCONNECTED"
    """


    """
    STATE_VM_RENAME_PENDING = "VM_RENAME_PENDING"
    """


    """
    STATE_VM_CONFIG_EDIT_PENDING = "VM_CONFIG_EDIT_PENDING"
    """


    """
    STATE_VM_NETWORK_EDIT_FAILED = "VM_NETWORK_EDIT_FAILED"
    """


    """
    STATE_VM_RENAME_FAILED = "VM_RENAME_FAILED"
    """


    """
    STATE_VM_CONFIG_EDIT_FAILED = "VM_CONFIG_EDIT_FAILED"
    """


    """
    STATE_VM_CONFIG_DISCREPANCY = "VM_CONFIG_DISCREPANCY"
    """


    """
    STATE_VM_NODE_REFRESH_FAILED = "VM_NODE_REFRESH_FAILED"
    """


    """
    STATE_VM_PLACEMENT_REFRESH_FAILED = "VM_PLACEMENT_REFRESH_FAILED"
    """


    """
    STATE_REGISTRATION_TIMEDOUT = "REGISTRATION_TIMEDOUT"
    """


    """



    _canonical_to_pep_names = {
                            'details': 'details',
                            'failure_code': 'failure_code',
                            'failure_message': 'failure_message',
                            'state': 'state',
                            'pending_change_list': 'pending_change_list',
                            'ipv6_dad_statuses': 'ipv6_dad_statuses',
                            }

    def __init__(self,
                 details=None,
                 failure_code=None,
                 failure_message=None,
                 state=None,
                 pending_change_list=None,
                 ipv6_dad_statuses=None,
                ):
        """
        :type  details: :class:`list` of :class:`ConfigurationStateElement` or ``None``
        :param details: Array of configuration state of various sub systems
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  failure_code: :class:`long` or ``None``
        :param failure_code: Error code format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  failure_message: :class:`str` or ``None``
        :param failure_message: Error message in case of failure
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  state: :class:`str` or ``None``
        :param state: Possible values are: 
            
            * :attr:`LogicalRouterPortState.STATE_PENDING`
            * :attr:`LogicalRouterPortState.STATE_IN_PROGRESS`
            * :attr:`LogicalRouterPortState.STATE_SUCCESS`
            * :attr:`LogicalRouterPortState.STATE_FAILED`
            * :attr:`LogicalRouterPortState.STATE_PARTIAL_SUCCESS`
            * :attr:`LogicalRouterPortState.STATE_ORPHANED`
            * :attr:`LogicalRouterPortState.STATE_UNKNOWN`
            * :attr:`LogicalRouterPortState.STATE_ERROR`
            * :attr:`LogicalRouterPortState.STATE_IN_SYNC`
            * :attr:`LogicalRouterPortState.STATE_NOT_AVAILABLE`
            * :attr:`LogicalRouterPortState.STATE_VM_DEPLOYMENT_QUEUED`
            * :attr:`LogicalRouterPortState.STATE_VM_DEPLOYMENT_IN_PROGRESS`
            * :attr:`LogicalRouterPortState.STATE_VM_DEPLOYMENT_FAILED`
            * :attr:`LogicalRouterPortState.STATE_VM_POWER_ON_IN_PROGRESS`
            * :attr:`LogicalRouterPortState.STATE_VM_POWER_ON_FAILED`
            * :attr:`LogicalRouterPortState.STATE_REGISTRATION_PENDING`
            * :attr:`LogicalRouterPortState.STATE_NODE_NOT_READY`
            * :attr:`LogicalRouterPortState.STATE_NODE_READY`
            * :attr:`LogicalRouterPortState.STATE_VM_POWER_OFF_IN_PROGRESS`
            * :attr:`LogicalRouterPortState.STATE_VM_POWER_OFF_FAILED`
            * :attr:`LogicalRouterPortState.STATE_VM_UNDEPLOY_IN_PROGRESS`
            * :attr:`LogicalRouterPortState.STATE_VM_UNDEPLOY_FAILED`
            * :attr:`LogicalRouterPortState.STATE_VM_UNDEPLOY_SUCCESSFUL`
            * :attr:`LogicalRouterPortState.STATE_EDGE_CONFIG_ERROR`
            * :attr:`LogicalRouterPortState.STATE_VM_DEPLOYMENT_RESTARTED`
            * :attr:`LogicalRouterPortState.STATE_REGISTRATION_FAILED`
            * :attr:`LogicalRouterPortState.STATE_TRANSPORT_NODE_SYNC_PENDING`
            *
              :attr:`LogicalRouterPortState.STATE_TRANSPORT_NODE_CONFIGURATION_MISSING`
            * :attr:`LogicalRouterPortState.STATE_EDGE_HARDWARE_NOT_SUPPORTED`
            *
              :attr:`LogicalRouterPortState.STATE_MULTIPLE_OVERLAY_TZS_NOT_SUPPORTED`
            *
              :attr:`LogicalRouterPortState.STATE_TN_OVERLAY_TZ_IN_USE_BY_EDGE_CLUSTER`
            * :attr:`LogicalRouterPortState.STATE_TZ_ENDPOINTS_NOT_SPECIFIED`
            * :attr:`LogicalRouterPortState.STATE_NO_PNIC_PREPARED_IN_EDGE`
            * :attr:`LogicalRouterPortState.STATE_APPLIANCE_INTERNAL_ERROR`
            * :attr:`LogicalRouterPortState.STATE_VTEP_DHCP_NOT_SUPPORTED`
            *
              :attr:`LogicalRouterPortState.STATE_UNSUPPORTED_HOST_SWITCH_PROFILE`
            *
              :attr:`LogicalRouterPortState.STATE_UPLINK_HOST_SWITCH_PROFILE_NOT_SPECIFIED`
            * :attr:`LogicalRouterPortState.STATE_HOSTSWITCH_PROFILE_NOT_FOUND`
            *
              :attr:`LogicalRouterPortState.STATE_LLDP_SEND_ENABLED_NOT_SUPPORTED`
            *
              :attr:`LogicalRouterPortState.STATE_UNSUPPORTED_NAMED_TEAMING_POLICY`
            *
              :attr:`LogicalRouterPortState.STATE_LBSRCID_NOT_SUPPORTED_FOR_EDGE_VM`
            *
              :attr:`LogicalRouterPortState.STATE_LACP_NOT_SUPPORTED_FOR_EDGE_VM`
            *
              :attr:`LogicalRouterPortState.STATE_STANDBY_UPLINKS_NOT_SUPPORTED_FOR_EDGE_VM`
            *
              :attr:`LogicalRouterPortState.STATE_MULTIPLE_ACTIVE_UPLINKS_NOT_SUPPORTED_FOR_EDGE`
            *
              :attr:`LogicalRouterPortState.STATE_UNSUPPORTED_LACP_LB_ALGO_FOR_NODE`
            *
              :attr:`LogicalRouterPortState.STATE_EDGE_NODE_VERSION_NOT_SUPPORTED`
            * :attr:`LogicalRouterPortState.STATE_NO_PNIC_SPECIFIED_IN_TN`
            * :attr:`LogicalRouterPortState.STATE_INVALID_PNIC_DEVICE_NAME`
            * :attr:`LogicalRouterPortState.STATE_TRANSPORT_NODE_READY`
            * :attr:`LogicalRouterPortState.STATE_VM_NETWORK_EDIT_PENDING`
            *
              :attr:`LogicalRouterPortState.STATE_UNSUPPORTED_DEFAULT_TEAMING_POLICY`
            * :attr:`LogicalRouterPortState.STATE_MPA_DISCONNECTED`
            * :attr:`LogicalRouterPortState.STATE_VM_RENAME_PENDING`
            * :attr:`LogicalRouterPortState.STATE_VM_CONFIG_EDIT_PENDING`
            * :attr:`LogicalRouterPortState.STATE_VM_NETWORK_EDIT_FAILED`
            * :attr:`LogicalRouterPortState.STATE_VM_RENAME_FAILED`
            * :attr:`LogicalRouterPortState.STATE_VM_CONFIG_EDIT_FAILED`
            * :attr:`LogicalRouterPortState.STATE_VM_CONFIG_DISCREPANCY`
            * :attr:`LogicalRouterPortState.STATE_VM_NODE_REFRESH_FAILED`
            * :attr:`LogicalRouterPortState.STATE_VM_PLACEMENT_REFRESH_FAILED`
            * :attr:`LogicalRouterPortState.STATE_REGISTRATION_TIMEDOUT`
            
            Gives details of state of desired configuration. Additional enums
            with more details on progress/success/error states are sent for
            edge node. The success states are NODE_READY and
            TRANSPORT_NODE_READY, pending states are {VM_DEPLOYMENT_QUEUED,
            VM_DEPLOYMENT_IN_PROGRESS, REGISTRATION_PENDING} and other values
            indicate failures. \"in_sync\" state indicates that the desired
            configuration has been received by the host to which it applies,
            but is not yet in effect. When the configuration is actually in
            effect, the state will change to \"success\". Please note, failed
            state is deprecated.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  pending_change_list: :class:`list` of :class:`str` or ``None``
        :param pending_change_list: Request identifier of the API which modified the entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  ipv6_dad_statuses: :class:`list` of :class:`IPv6DADStatus` or ``None``
        :param ipv6_dad_statuses: Array of DAD status which contains DAD information for IP addresses
            on the port.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.details = details
        self.failure_code = failure_code
        self.failure_message = failure_message
        self.state = state
        self.pending_change_list = pending_change_list
        self.ipv6_dad_statuses = ipv6_dad_statuses
        VapiStruct.__init__(self)


LogicalRouterPortState._set_binding_type(type.StructType(
    'com.vmware.nsx.model.logical_router_port_state', {
        'details': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ConfigurationStateElement'))),
        'failure_code': type.OptionalType(type.IntegerType()),
        'failure_message': type.OptionalType(type.StringType()),
        'state': type.OptionalType(type.StringType()),
        'pending_change_list': type.OptionalType(type.ListType(type.StringType())),
        'ipv6_dad_statuses': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IPv6DADStatus'))),
    },
    LogicalRouterPortState,
    False,
    None))



class LogicalRouterPortStatistics(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'logical_router_port_id': 'logical_router_port_id',
                            'per_node_statistics': 'per_node_statistics',
                            }

    def __init__(self,
                 logical_router_port_id=None,
                 per_node_statistics=None,
                ):
        """
        :type  logical_router_port_id: :class:`str` or ``None``
        :param logical_router_port_id: The ID of the logical router port
        :type  per_node_statistics: :class:`list` of :class:`LogicalRouterPortStatisticsPerNode` or ``None``
        :param per_node_statistics: Per Node Statistics
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.logical_router_port_id = logical_router_port_id
        self.per_node_statistics = per_node_statistics
        VapiStruct.__init__(self)


LogicalRouterPortStatistics._set_binding_type(type.StructType(
    'com.vmware.nsx.model.logical_router_port_statistics', {
        'logical_router_port_id': type.OptionalType(type.StringType()),
        'per_node_statistics': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'LogicalRouterPortStatisticsPerNode'))),
    },
    LogicalRouterPortStatistics,
    False,
    None))



class LogicalRouterPortStatisticsPerNode(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'last_update_timestamp': 'last_update_timestamp',
                            'rx': 'rx',
                            'tx': 'tx',
                            'transport_node_id': 'transport_node_id',
                            }

    def __init__(self,
                 last_update_timestamp=None,
                 rx=None,
                 tx=None,
                 transport_node_id=None,
                ):
        """
        :type  last_update_timestamp: :class:`long` or ``None``
        :param last_update_timestamp: Timestamp when the data was last updated; unset if data source has
            never updated the data. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  rx: :class:`LogicalRouterPortCounters` or ``None``
        :param rx: 
        :type  tx: :class:`LogicalRouterPortCounters` or ``None``
        :param tx: 
        :type  transport_node_id: :class:`str` or ``None``
        :param transport_node_id: The ID of the TransportNode
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.last_update_timestamp = last_update_timestamp
        self.rx = rx
        self.tx = tx
        self.transport_node_id = transport_node_id
        VapiStruct.__init__(self)


LogicalRouterPortStatisticsPerNode._set_binding_type(type.StructType(
    'com.vmware.nsx.model.logical_router_port_statistics_per_node', {
        'last_update_timestamp': type.OptionalType(type.IntegerType()),
        'rx': type.OptionalType(type.ReferenceType(__name__, 'LogicalRouterPortCounters')),
        'tx': type.OptionalType(type.ReferenceType(__name__, 'LogicalRouterPortCounters')),
        'transport_node_id': type.OptionalType(type.StringType()),
    },
    LogicalRouterPortStatisticsPerNode,
    False,
    None))



class LogicalRouterPortStatisticsSummary(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'last_update_timestamp': 'last_update_timestamp',
                            'rx': 'rx',
                            'tx': 'tx',
                            'logical_router_port_id': 'logical_router_port_id',
                            }

    def __init__(self,
                 last_update_timestamp=None,
                 rx=None,
                 tx=None,
                 logical_router_port_id=None,
                ):
        """
        :type  last_update_timestamp: :class:`long` or ``None``
        :param last_update_timestamp: Timestamp when the data was last updated; unset if data source has
            never updated the data. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  rx: :class:`LogicalRouterPortCounters` or ``None``
        :param rx: 
        :type  tx: :class:`LogicalRouterPortCounters` or ``None``
        :param tx: 
        :type  logical_router_port_id: :class:`str` or ``None``
        :param logical_router_port_id: The ID of the logical router port
        """
        self.last_update_timestamp = last_update_timestamp
        self.rx = rx
        self.tx = tx
        self.logical_router_port_id = logical_router_port_id
        VapiStruct.__init__(self)


LogicalRouterPortStatisticsSummary._set_binding_type(type.StructType(
    'com.vmware.nsx.model.logical_router_port_statistics_summary', {
        'last_update_timestamp': type.OptionalType(type.IntegerType()),
        'rx': type.OptionalType(type.ReferenceType(__name__, 'LogicalRouterPortCounters')),
        'tx': type.OptionalType(type.ReferenceType(__name__, 'LogicalRouterPortCounters')),
        'logical_router_port_id': type.OptionalType(type.StringType()),
    },
    LogicalRouterPortStatisticsSummary,
    False,
    None))



class LogicalRouterRouteCsvRecord(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'admin_distance': 'admin_distance',
                            'logical_router_port_id': 'logical_router_port_id',
                            'lr_component_id': 'lr_component_id',
                            'lr_component_type': 'lr_component_type',
                            'network': 'network',
                            'next_hop': 'next_hop',
                            'route_type': 'route_type',
                            }

    def __init__(self,
                 admin_distance=None,
                 logical_router_port_id=None,
                 lr_component_id=None,
                 lr_component_type=None,
                 network=None,
                 next_hop=None,
                 route_type=None,
                ):
        """
        :type  admin_distance: :class:`long` or ``None``
        :param admin_distance: The admin distance of the next hop format: int64
        :type  logical_router_port_id: :class:`str` or ``None``
        :param logical_router_port_id: The id of the logical router port which is used as the next hop
        :type  lr_component_id: :class:`str` or ``None``
        :param lr_component_id: Logical router component(Service Router/Distributed Router) id
        :type  lr_component_type: :class:`str` or ``None``
        :param lr_component_type: Logical router component(Service Router/Distributed Router) type
        :type  network: :class:`str` or ``None``
        :param network: CIDR network address format: ip-cidr-block
        :type  next_hop: :class:`str` or ``None``
        :param next_hop: The IP of the next hop format: ip
        :type  route_type: :class:`str` or ``None``
        :param route_type: Route type (USER, CONNECTED, NSX_INTERNAL,..)
        """
        self.admin_distance = admin_distance
        self.logical_router_port_id = logical_router_port_id
        self.lr_component_id = lr_component_id
        self.lr_component_type = lr_component_type
        self.network = network
        self.next_hop = next_hop
        self.route_type = route_type
        VapiStruct.__init__(self)


LogicalRouterRouteCsvRecord._set_binding_type(type.StructType(
    'com.vmware.nsx.model.logical_router_route_csv_record', {
        'admin_distance': type.OptionalType(type.IntegerType()),
        'logical_router_port_id': type.OptionalType(type.StringType()),
        'lr_component_id': type.OptionalType(type.StringType()),
        'lr_component_type': type.OptionalType(type.StringType()),
        'network': type.OptionalType(type.StringType()),
        'next_hop': type.OptionalType(type.StringType()),
        'route_type': type.OptionalType(type.StringType()),
    },
    LogicalRouterRouteCsvRecord,
    False,
    None))



class LogicalRouterRouteEntry(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'admin_distance': 'admin_distance',
                            'logical_router_port_id': 'logical_router_port_id',
                            'lr_component_id': 'lr_component_id',
                            'lr_component_type': 'lr_component_type',
                            'network': 'network',
                            'next_hop': 'next_hop',
                            'route_type': 'route_type',
                            }

    def __init__(self,
                 admin_distance=None,
                 logical_router_port_id=None,
                 lr_component_id=None,
                 lr_component_type=None,
                 network=None,
                 next_hop=None,
                 route_type=None,
                ):
        """
        :type  admin_distance: :class:`long` or ``None``
        :param admin_distance: The admin distance of the next hop format: int64
        :type  logical_router_port_id: :class:`str` or ``None``
        :param logical_router_port_id: The id of the logical router port which is used as the next hop
        :type  lr_component_id: :class:`str` or ``None``
        :param lr_component_id: Logical router component(Service Router/Distributed Router) id
        :type  lr_component_type: :class:`str` or ``None``
        :param lr_component_type: Logical router component(Service Router/Distributed Router) type
        :type  network: :class:`str` or ``None``
        :param network: CIDR network address format: ip-cidr-block
        :type  next_hop: :class:`str` or ``None``
        :param next_hop: The IP address of the next hop format: ip
        :type  route_type: :class:`str` or ``None``
        :param route_type: Route type (USER, CONNECTED, NSX_INTERNAL,..)
        """
        self.admin_distance = admin_distance
        self.logical_router_port_id = logical_router_port_id
        self.lr_component_id = lr_component_id
        self.lr_component_type = lr_component_type
        self.network = network
        self.next_hop = next_hop
        self.route_type = route_type
        VapiStruct.__init__(self)


LogicalRouterRouteEntry._set_binding_type(type.StructType(
    'com.vmware.nsx.model.logical_router_route_entry', {
        'admin_distance': type.OptionalType(type.IntegerType()),
        'logical_router_port_id': type.OptionalType(type.StringType()),
        'lr_component_id': type.OptionalType(type.StringType()),
        'lr_component_type': type.OptionalType(type.StringType()),
        'network': type.OptionalType(type.StringType()),
        'next_hop': type.OptionalType(type.StringType()),
        'route_type': type.OptionalType(type.StringType()),
    },
    LogicalRouterRouteEntry,
    False,
    None))



class LogicalRouterRouteTable(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'last_update_timestamp': 'last_update_timestamp',
                            'logical_router_id': 'logical_router_id',
                            'logical_router_name': 'logical_router_name',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 last_update_timestamp=None,
                 logical_router_id=None,
                 logical_router_name=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_update_timestamp: :class:`long` or ``None``
        :param last_update_timestamp: Timestamp when the data was last updated; unset if data source has
            never updated the data. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  logical_router_id: :class:`str` or ``None``
        :param logical_router_id: The id of the logical router
        :type  logical_router_name: :class:`str` or ``None``
        :param logical_router_name: Name of the logical router
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`LogicalRouterRouteEntry` or ``None``
        :param results: 
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.last_update_timestamp = last_update_timestamp
        self.logical_router_id = logical_router_id
        self.logical_router_name = logical_router_name
        self.results = results
        VapiStruct.__init__(self)


LogicalRouterRouteTable._set_binding_type(type.StructType(
    'com.vmware.nsx.model.logical_router_route_table', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'last_update_timestamp': type.OptionalType(type.IntegerType()),
        'logical_router_id': type.OptionalType(type.StringType()),
        'logical_router_name': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'LogicalRouterRouteEntry'))),
    },
    LogicalRouterRouteTable,
    False,
    None))



class LogicalRouterRouteTableInCsvFormat(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'file_name': 'file_name',
                            'last_update_timestamp': 'last_update_timestamp',
                            'results': 'results',
                            }

    def __init__(self,
                 file_name=None,
                 last_update_timestamp=None,
                 results=None,
                ):
        """
        :type  file_name: :class:`str` or ``None``
        :param file_name: File name set by HTTP server if API returns CSV result as a file.
        :type  last_update_timestamp: :class:`long` or ``None``
        :param last_update_timestamp: Timestamp when the data was last updated; unset if data source has
            never updated the data. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`LogicalRouterRouteCsvRecord` or ``None``
        :param results: 
        """
        self.file_name = file_name
        self.last_update_timestamp = last_update_timestamp
        self.results = results
        VapiStruct.__init__(self)


LogicalRouterRouteTableInCsvFormat._set_binding_type(type.StructType(
    'com.vmware.nsx.model.logical_router_route_table_in_csv_format', {
        'file_name': type.OptionalType(type.StringType()),
        'last_update_timestamp': type.OptionalType(type.IntegerType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'LogicalRouterRouteCsvRecord'))),
    },
    LogicalRouterRouteTableInCsvFormat,
    False,
    None))



class LogicalRouterState(VapiStruct):
    """
    This holds the state of Logical Router. If there are errors in realizing LR
    outside of MP, it gives details of the components and specific errors.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATE_PENDING = "pending"
    """


    """
    STATE_IN_PROGRESS = "in_progress"
    """


    """
    STATE_SUCCESS = "success"
    """


    """
    STATE_FAILED = "failed"
    """


    """
    STATE_PARTIAL_SUCCESS = "partial_success"
    """


    """
    STATE_ORPHANED = "orphaned"
    """


    """
    STATE_UNKNOWN = "unknown"
    """


    """
    STATE_ERROR = "error"
    """


    """
    STATE_IN_SYNC = "in_sync"
    """


    """
    STATE_NOT_AVAILABLE = "NOT_AVAILABLE"
    """


    """
    STATE_VM_DEPLOYMENT_QUEUED = "VM_DEPLOYMENT_QUEUED"
    """


    """
    STATE_VM_DEPLOYMENT_IN_PROGRESS = "VM_DEPLOYMENT_IN_PROGRESS"
    """


    """
    STATE_VM_DEPLOYMENT_FAILED = "VM_DEPLOYMENT_FAILED"
    """


    """
    STATE_VM_POWER_ON_IN_PROGRESS = "VM_POWER_ON_IN_PROGRESS"
    """


    """
    STATE_VM_POWER_ON_FAILED = "VM_POWER_ON_FAILED"
    """


    """
    STATE_REGISTRATION_PENDING = "REGISTRATION_PENDING"
    """


    """
    STATE_NODE_NOT_READY = "NODE_NOT_READY"
    """


    """
    STATE_NODE_READY = "NODE_READY"
    """


    """
    STATE_VM_POWER_OFF_IN_PROGRESS = "VM_POWER_OFF_IN_PROGRESS"
    """


    """
    STATE_VM_POWER_OFF_FAILED = "VM_POWER_OFF_FAILED"
    """


    """
    STATE_VM_UNDEPLOY_IN_PROGRESS = "VM_UNDEPLOY_IN_PROGRESS"
    """


    """
    STATE_VM_UNDEPLOY_FAILED = "VM_UNDEPLOY_FAILED"
    """


    """
    STATE_VM_UNDEPLOY_SUCCESSFUL = "VM_UNDEPLOY_SUCCESSFUL"
    """


    """
    STATE_EDGE_CONFIG_ERROR = "EDGE_CONFIG_ERROR"
    """


    """
    STATE_VM_DEPLOYMENT_RESTARTED = "VM_DEPLOYMENT_RESTARTED"
    """


    """
    STATE_REGISTRATION_FAILED = "REGISTRATION_FAILED"
    """


    """
    STATE_TRANSPORT_NODE_SYNC_PENDING = "TRANSPORT_NODE_SYNC_PENDING"
    """


    """
    STATE_TRANSPORT_NODE_CONFIGURATION_MISSING = "TRANSPORT_NODE_CONFIGURATION_MISSING"
    """


    """
    STATE_EDGE_HARDWARE_NOT_SUPPORTED = "EDGE_HARDWARE_NOT_SUPPORTED"
    """


    """
    STATE_MULTIPLE_OVERLAY_TZS_NOT_SUPPORTED = "MULTIPLE_OVERLAY_TZS_NOT_SUPPORTED"
    """


    """
    STATE_TN_OVERLAY_TZ_IN_USE_BY_EDGE_CLUSTER = "TN_OVERLAY_TZ_IN_USE_BY_EDGE_CLUSTER"
    """


    """
    STATE_TZ_ENDPOINTS_NOT_SPECIFIED = "TZ_ENDPOINTS_NOT_SPECIFIED"
    """


    """
    STATE_NO_PNIC_PREPARED_IN_EDGE = "NO_PNIC_PREPARED_IN_EDGE"
    """


    """
    STATE_APPLIANCE_INTERNAL_ERROR = "APPLIANCE_INTERNAL_ERROR"
    """


    """
    STATE_VTEP_DHCP_NOT_SUPPORTED = "VTEP_DHCP_NOT_SUPPORTED"
    """


    """
    STATE_UNSUPPORTED_HOST_SWITCH_PROFILE = "UNSUPPORTED_HOST_SWITCH_PROFILE"
    """


    """
    STATE_UPLINK_HOST_SWITCH_PROFILE_NOT_SPECIFIED = "UPLINK_HOST_SWITCH_PROFILE_NOT_SPECIFIED"
    """


    """
    STATE_HOSTSWITCH_PROFILE_NOT_FOUND = "HOSTSWITCH_PROFILE_NOT_FOUND"
    """


    """
    STATE_LLDP_SEND_ENABLED_NOT_SUPPORTED = "LLDP_SEND_ENABLED_NOT_SUPPORTED"
    """


    """
    STATE_UNSUPPORTED_NAMED_TEAMING_POLICY = "UNSUPPORTED_NAMED_TEAMING_POLICY"
    """


    """
    STATE_LBSRCID_NOT_SUPPORTED_FOR_EDGE_VM = "LBSRCID_NOT_SUPPORTED_FOR_EDGE_VM"
    """


    """
    STATE_LACP_NOT_SUPPORTED_FOR_EDGE_VM = "LACP_NOT_SUPPORTED_FOR_EDGE_VM"
    """


    """
    STATE_STANDBY_UPLINKS_NOT_SUPPORTED_FOR_EDGE_VM = "STANDBY_UPLINKS_NOT_SUPPORTED_FOR_EDGE_VM"
    """


    """
    STATE_MULTIPLE_ACTIVE_UPLINKS_NOT_SUPPORTED_FOR_EDGE = "MULTIPLE_ACTIVE_UPLINKS_NOT_SUPPORTED_FOR_EDGE"
    """


    """
    STATE_UNSUPPORTED_LACP_LB_ALGO_FOR_NODE = "UNSUPPORTED_LACP_LB_ALGO_FOR_NODE"
    """


    """
    STATE_EDGE_NODE_VERSION_NOT_SUPPORTED = "EDGE_NODE_VERSION_NOT_SUPPORTED"
    """


    """
    STATE_NO_PNIC_SPECIFIED_IN_TN = "NO_PNIC_SPECIFIED_IN_TN"
    """


    """
    STATE_INVALID_PNIC_DEVICE_NAME = "INVALID_PNIC_DEVICE_NAME"
    """


    """
    STATE_TRANSPORT_NODE_READY = "TRANSPORT_NODE_READY"
    """


    """
    STATE_VM_NETWORK_EDIT_PENDING = "VM_NETWORK_EDIT_PENDING"
    """


    """
    STATE_UNSUPPORTED_DEFAULT_TEAMING_POLICY = "UNSUPPORTED_DEFAULT_TEAMING_POLICY"
    """


    """
    STATE_MPA_DISCONNECTED = "MPA_DISCONNECTED"
    """


    """
    STATE_VM_RENAME_PENDING = "VM_RENAME_PENDING"
    """


    """
    STATE_VM_CONFIG_EDIT_PENDING = "VM_CONFIG_EDIT_PENDING"
    """


    """
    STATE_VM_NETWORK_EDIT_FAILED = "VM_NETWORK_EDIT_FAILED"
    """


    """
    STATE_VM_RENAME_FAILED = "VM_RENAME_FAILED"
    """


    """
    STATE_VM_CONFIG_EDIT_FAILED = "VM_CONFIG_EDIT_FAILED"
    """


    """
    STATE_VM_CONFIG_DISCREPANCY = "VM_CONFIG_DISCREPANCY"
    """


    """
    STATE_VM_NODE_REFRESH_FAILED = "VM_NODE_REFRESH_FAILED"
    """


    """
    STATE_VM_PLACEMENT_REFRESH_FAILED = "VM_PLACEMENT_REFRESH_FAILED"
    """


    """
    STATE_REGISTRATION_TIMEDOUT = "REGISTRATION_TIMEDOUT"
    """


    """



    _canonical_to_pep_names = {
                            'details': 'details',
                            'failure_code': 'failure_code',
                            'failure_message': 'failure_message',
                            'state': 'state',
                            'pending_change_list': 'pending_change_list',
                            }

    def __init__(self,
                 details=None,
                 failure_code=None,
                 failure_message=None,
                 state=None,
                 pending_change_list=None,
                ):
        """
        :type  details: :class:`list` of :class:`ConfigurationStateElement` or ``None``
        :param details: Array of configuration state of various sub systems
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  failure_code: :class:`long` or ``None``
        :param failure_code: Error code format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  failure_message: :class:`str` or ``None``
        :param failure_message: Error message in case of failure
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  state: :class:`str` or ``None``
        :param state: Possible values are: 
            
            * :attr:`LogicalRouterState.STATE_PENDING`
            * :attr:`LogicalRouterState.STATE_IN_PROGRESS`
            * :attr:`LogicalRouterState.STATE_SUCCESS`
            * :attr:`LogicalRouterState.STATE_FAILED`
            * :attr:`LogicalRouterState.STATE_PARTIAL_SUCCESS`
            * :attr:`LogicalRouterState.STATE_ORPHANED`
            * :attr:`LogicalRouterState.STATE_UNKNOWN`
            * :attr:`LogicalRouterState.STATE_ERROR`
            * :attr:`LogicalRouterState.STATE_IN_SYNC`
            * :attr:`LogicalRouterState.STATE_NOT_AVAILABLE`
            * :attr:`LogicalRouterState.STATE_VM_DEPLOYMENT_QUEUED`
            * :attr:`LogicalRouterState.STATE_VM_DEPLOYMENT_IN_PROGRESS`
            * :attr:`LogicalRouterState.STATE_VM_DEPLOYMENT_FAILED`
            * :attr:`LogicalRouterState.STATE_VM_POWER_ON_IN_PROGRESS`
            * :attr:`LogicalRouterState.STATE_VM_POWER_ON_FAILED`
            * :attr:`LogicalRouterState.STATE_REGISTRATION_PENDING`
            * :attr:`LogicalRouterState.STATE_NODE_NOT_READY`
            * :attr:`LogicalRouterState.STATE_NODE_READY`
            * :attr:`LogicalRouterState.STATE_VM_POWER_OFF_IN_PROGRESS`
            * :attr:`LogicalRouterState.STATE_VM_POWER_OFF_FAILED`
            * :attr:`LogicalRouterState.STATE_VM_UNDEPLOY_IN_PROGRESS`
            * :attr:`LogicalRouterState.STATE_VM_UNDEPLOY_FAILED`
            * :attr:`LogicalRouterState.STATE_VM_UNDEPLOY_SUCCESSFUL`
            * :attr:`LogicalRouterState.STATE_EDGE_CONFIG_ERROR`
            * :attr:`LogicalRouterState.STATE_VM_DEPLOYMENT_RESTARTED`
            * :attr:`LogicalRouterState.STATE_REGISTRATION_FAILED`
            * :attr:`LogicalRouterState.STATE_TRANSPORT_NODE_SYNC_PENDING`
            *
              :attr:`LogicalRouterState.STATE_TRANSPORT_NODE_CONFIGURATION_MISSING`
            * :attr:`LogicalRouterState.STATE_EDGE_HARDWARE_NOT_SUPPORTED`
            *
              :attr:`LogicalRouterState.STATE_MULTIPLE_OVERLAY_TZS_NOT_SUPPORTED`
            *
              :attr:`LogicalRouterState.STATE_TN_OVERLAY_TZ_IN_USE_BY_EDGE_CLUSTER`
            * :attr:`LogicalRouterState.STATE_TZ_ENDPOINTS_NOT_SPECIFIED`
            * :attr:`LogicalRouterState.STATE_NO_PNIC_PREPARED_IN_EDGE`
            * :attr:`LogicalRouterState.STATE_APPLIANCE_INTERNAL_ERROR`
            * :attr:`LogicalRouterState.STATE_VTEP_DHCP_NOT_SUPPORTED`
            * :attr:`LogicalRouterState.STATE_UNSUPPORTED_HOST_SWITCH_PROFILE`
            *
              :attr:`LogicalRouterState.STATE_UPLINK_HOST_SWITCH_PROFILE_NOT_SPECIFIED`
            * :attr:`LogicalRouterState.STATE_HOSTSWITCH_PROFILE_NOT_FOUND`
            * :attr:`LogicalRouterState.STATE_LLDP_SEND_ENABLED_NOT_SUPPORTED`
            * :attr:`LogicalRouterState.STATE_UNSUPPORTED_NAMED_TEAMING_POLICY`
            *
              :attr:`LogicalRouterState.STATE_LBSRCID_NOT_SUPPORTED_FOR_EDGE_VM`
            * :attr:`LogicalRouterState.STATE_LACP_NOT_SUPPORTED_FOR_EDGE_VM`
            *
              :attr:`LogicalRouterState.STATE_STANDBY_UPLINKS_NOT_SUPPORTED_FOR_EDGE_VM`
            *
              :attr:`LogicalRouterState.STATE_MULTIPLE_ACTIVE_UPLINKS_NOT_SUPPORTED_FOR_EDGE`
            *
              :attr:`LogicalRouterState.STATE_UNSUPPORTED_LACP_LB_ALGO_FOR_NODE`
            * :attr:`LogicalRouterState.STATE_EDGE_NODE_VERSION_NOT_SUPPORTED`
            * :attr:`LogicalRouterState.STATE_NO_PNIC_SPECIFIED_IN_TN`
            * :attr:`LogicalRouterState.STATE_INVALID_PNIC_DEVICE_NAME`
            * :attr:`LogicalRouterState.STATE_TRANSPORT_NODE_READY`
            * :attr:`LogicalRouterState.STATE_VM_NETWORK_EDIT_PENDING`
            *
              :attr:`LogicalRouterState.STATE_UNSUPPORTED_DEFAULT_TEAMING_POLICY`
            * :attr:`LogicalRouterState.STATE_MPA_DISCONNECTED`
            * :attr:`LogicalRouterState.STATE_VM_RENAME_PENDING`
            * :attr:`LogicalRouterState.STATE_VM_CONFIG_EDIT_PENDING`
            * :attr:`LogicalRouterState.STATE_VM_NETWORK_EDIT_FAILED`
            * :attr:`LogicalRouterState.STATE_VM_RENAME_FAILED`
            * :attr:`LogicalRouterState.STATE_VM_CONFIG_EDIT_FAILED`
            * :attr:`LogicalRouterState.STATE_VM_CONFIG_DISCREPANCY`
            * :attr:`LogicalRouterState.STATE_VM_NODE_REFRESH_FAILED`
            * :attr:`LogicalRouterState.STATE_VM_PLACEMENT_REFRESH_FAILED`
            * :attr:`LogicalRouterState.STATE_REGISTRATION_TIMEDOUT`
            
            Gives details of state of desired configuration. Additional enums
            with more details on progress/success/error states are sent for
            edge node. The success states are NODE_READY and
            TRANSPORT_NODE_READY, pending states are {VM_DEPLOYMENT_QUEUED,
            VM_DEPLOYMENT_IN_PROGRESS, REGISTRATION_PENDING} and other values
            indicate failures. \"in_sync\" state indicates that the desired
            configuration has been received by the host to which it applies,
            but is not yet in effect. When the configuration is actually in
            effect, the state will change to \"success\". Please note, failed
            state is deprecated.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  pending_change_list: :class:`list` of :class:`str` or ``None``
        :param pending_change_list: Request identifier of the API which modified the entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.details = details
        self.failure_code = failure_code
        self.failure_message = failure_message
        self.state = state
        self.pending_change_list = pending_change_list
        VapiStruct.__init__(self)


LogicalRouterState._set_binding_type(type.StructType(
    'com.vmware.nsx.model.logical_router_state', {
        'details': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ConfigurationStateElement'))),
        'failure_code': type.OptionalType(type.IntegerType()),
        'failure_message': type.OptionalType(type.StringType()),
        'state': type.OptionalType(type.StringType()),
        'pending_change_list': type.OptionalType(type.ListType(type.StringType())),
    },
    LogicalRouterState,
    False,
    None))



class LogicalRouterStatus(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    LOCALE_OPERATION_MODE_PRIMARY_LOCATION = "PRIMARY_LOCATION"
    """


    """
    LOCALE_OPERATION_MODE_SECONDARY_LOCATION = "SECONDARY_LOCATION"
    """


    """



    _canonical_to_pep_names = {
                            'last_update_timestamp': 'last_update_timestamp',
                            'locale_operation_mode': 'locale_operation_mode',
                            'logical_router_id': 'logical_router_id',
                            'per_node_status': 'per_node_status',
                            }

    def __init__(self,
                 last_update_timestamp=None,
                 locale_operation_mode=None,
                 logical_router_id=None,
                 per_node_status=None,
                ):
        """
        :type  last_update_timestamp: :class:`long` or ``None``
        :param last_update_timestamp: Timestamp when the data was last updated; unset if data source has
            never updated the data. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  locale_operation_mode: :class:`str` or ``None``
        :param locale_operation_mode: Possible values are: 
            
            *
              :attr:`LogicalRouterStatus.LOCALE_OPERATION_MODE_PRIMARY_LOCATION`
            *
              :attr:`LogicalRouterStatus.LOCALE_OPERATION_MODE_SECONDARY_LOCATION`
            
             Egress mode for the logical router at given mode
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  logical_router_id: :class:`str` or ``None``
        :param logical_router_id: The id of the logical router
        :type  per_node_status: :class:`list` of :class:`LogicalRouterStatusPerNode` or ``None``
        :param per_node_status: Per Node Status
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.last_update_timestamp = last_update_timestamp
        self.locale_operation_mode = locale_operation_mode
        self.logical_router_id = logical_router_id
        self.per_node_status = per_node_status
        VapiStruct.__init__(self)


LogicalRouterStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.logical_router_status', {
        'last_update_timestamp': type.OptionalType(type.IntegerType()),
        'locale_operation_mode': type.OptionalType(type.StringType()),
        'logical_router_id': type.OptionalType(type.StringType()),
        'per_node_status': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'LogicalRouterStatusPerNode'))),
    },
    LogicalRouterStatus,
    False,
    None))



class LogicalRouterStatusPerNode(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    HIGH_AVAILABILITY_STATUS_ACTIVE = "ACTIVE"
    """


    """
    HIGH_AVAILABILITY_STATUS_STANDBY = "STANDBY"
    """


    """
    HIGH_AVAILABILITY_STATUS_DOWN = "DOWN"
    """


    """
    HIGH_AVAILABILITY_STATUS_SYNC = "SYNC"
    """


    """
    HIGH_AVAILABILITY_STATUS_UNKNOWN = "UNKNOWN"
    """


    """
    HIGH_AVAILABILITY_STATUS_ADMIN_DOWN = "ADMIN_DOWN"
    """


    """



    _canonical_to_pep_names = {
                            'high_availability_status': 'high_availability_status',
                            'service_router_id': 'service_router_id',
                            'transport_node_id': 'transport_node_id',
                            }

    def __init__(self,
                 high_availability_status=None,
                 service_router_id=None,
                 transport_node_id=None,
                ):
        """
        :type  high_availability_status: :class:`str` or ``None``
        :param high_availability_status: Possible values are: 
            
            *
              :attr:`LogicalRouterStatusPerNode.HIGH_AVAILABILITY_STATUS_ACTIVE`
            *
              :attr:`LogicalRouterStatusPerNode.HIGH_AVAILABILITY_STATUS_STANDBY`
            * :attr:`LogicalRouterStatusPerNode.HIGH_AVAILABILITY_STATUS_DOWN`
            * :attr:`LogicalRouterStatusPerNode.HIGH_AVAILABILITY_STATUS_SYNC`
            *
              :attr:`LogicalRouterStatusPerNode.HIGH_AVAILABILITY_STATUS_UNKNOWN`
            *
              :attr:`LogicalRouterStatusPerNode.HIGH_AVAILABILITY_STATUS_ADMIN_DOWN`
            
             A service router's HA status on an edge node
        :type  service_router_id: :class:`str` or ``None``
        :param service_router_id: id of the service router where the router status is retrieved.
        :type  transport_node_id: :class:`str` or ``None``
        :param transport_node_id: id of the transport node where the router status is retrieved.
        """
        self.high_availability_status = high_availability_status
        self.service_router_id = service_router_id
        self.transport_node_id = transport_node_id
        VapiStruct.__init__(self)


LogicalRouterStatusPerNode._set_binding_type(type.StructType(
    'com.vmware.nsx.model.logical_router_status_per_node', {
        'high_availability_status': type.OptionalType(type.StringType()),
        'service_router_id': type.OptionalType(type.StringType()),
        'transport_node_id': type.OptionalType(type.StringType()),
    },
    LogicalRouterStatusPerNode,
    False,
    None))



class LogicalRouterUpLinkPort(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LogicalRouterUpLinkPort"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    URPF_MODE_NONE = "NONE"
    """


    """
    URPF_MODE_STRICT = "STRICT"
    """


    """



    _canonical_to_pep_names = {
                            'edge_cluster_member_index': 'edge_cluster_member_index',
                            'linked_logical_switch_port_id': 'linked_logical_switch_port_id',
                            'mac_address': 'mac_address',
                            'mtu': 'mtu',
                            'ndra_prefix_config': 'ndra_prefix_config',
                            'ndra_profile_id': 'ndra_profile_id',
                            'pim_config': 'pim_config',
                            'subnets': 'subnets',
                            'urpf_mode': 'urpf_mode',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'logical_router_id': 'logical_router_id',
                            'service_bindings': 'service_bindings',
                            }

    def __init__(self,
                 edge_cluster_member_index=None,
                 linked_logical_switch_port_id=None,
                 mac_address=None,
                 mtu=None,
                 ndra_prefix_config=None,
                 ndra_profile_id=None,
                 pim_config=None,
                 subnets=None,
                 urpf_mode=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='LogicalRouterUpLinkPort',
                 tags=None,
                 logical_router_id=None,
                 service_bindings=None,
                ):
        """
        :type  edge_cluster_member_index: :class:`list` of :class:`long` or ``None``
        :param edge_cluster_member_index: Member index of the edge node on the cluster format: int64
        :type  linked_logical_switch_port_id: :class:`ResourceReference` or ``None``
        :param linked_logical_switch_port_id: Reference to the logical switch port to connect to
        :type  mac_address: :class:`str` or ``None``
        :param mac_address: MAC address
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  mtu: :class:`long` or ``None``
        :param mtu: Maximum transmission unit specifies the size of the largest packet
            that a network protocol can transmit. If not specified, the global
            logical MTU set in the /api/v1/global-configs/RoutingGlobalConfig
            API will be used. format: int64
        :type  ndra_prefix_config: :class:`list` of :class:`NDRAPrefixConfig` or ``None``
        :param ndra_prefix_config: Configuration to override the neighbor discovery router
            advertisement prefix time parameters at the subnet level. Note that
            users are allowed to override the prefix time only for IPv6 subnets
            which are configured on the port.
        :type  ndra_profile_id: :class:`str` or ``None``
        :param ndra_profile_id: Identifier of Neighbor Discovery Router Advertisement profile
            associated with port. When NDRA profile id is associated at both
            the port level and logical router level, the profile id specified
            at port level takes the precedence.
        :type  pim_config: :class:`InterfacePimConfig` or ``None``
        :param pim_config: PIM[Protocol Independent Multicast] configuration parameters.
        :type  subnets: :class:`list` of :class:`IPSubnet` or ``None``
        :param subnets: Logical router port subnets
        :type  urpf_mode: :class:`str` or ``None``
        :param urpf_mode: Possible values are: 
            
            * :attr:`LogicalRouterUpLinkPort.URPF_MODE_NONE`
            * :attr:`LogicalRouterUpLinkPort.URPF_MODE_STRICT`
            
             Unicast Reverse Path Forwarding mode
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`LogicalRouterPort.RESOURCE_TYPE_LOGICALROUTERUPLINKPORT`
            * :attr:`LogicalRouterPort.RESOURCE_TYPE_LOGICALROUTERDOWNLINKPORT`
            *
              :attr:`LogicalRouterPort.RESOURCE_TYPE_LOGICALROUTERLINKPORTONTIER0`
            *
              :attr:`LogicalRouterPort.RESOURCE_TYPE_LOGICALROUTERLINKPORTONTIER1`
            * :attr:`LogicalRouterPort.RESOURCE_TYPE_LOGICALROUTERLOOPBACKPORT`
            * :attr:`LogicalRouterPort.RESOURCE_TYPE_LOGICALROUTERIPTUNNELPORT`
            *
              :attr:`LogicalRouterPort.RESOURCE_TYPE_LOGICALROUTERCENTRALIZEDSERVICEPORT`
            
            LogicalRouterUpLinkPort is allowed only on TIER0 logical router. It
            is the north facing port of the logical router.
            LogicalRouterLinkPortOnTIER0 is allowed only on TIER0 logical
            router. This is the port where the LogicalRouterLinkPortOnTIER1 of
            TIER1 logical router connects to. LogicalRouterLinkPortOnTIER1 is
            allowed only on TIER1 logical router. This is the port using which
            the user connected to TIER1 logical router for upwards connectivity
            via TIER0 logical router. Connect this port to the
            LogicalRouterLinkPortOnTIER0 of the TIER0 logical router.
            LogicalRouterDownLinkPort is for the connected subnets on the
            logical router. LogicalRouterLoopbackPort is a loopback port for
            logical router component which is placed on chosen edge cluster
            member. LogicalRouterIPTunnelPort is a IPSec VPN tunnel port
            created on logical router when route based VPN session configured.
            LogicalRouterCentralizedServicePort is allowed only on
            Active/Standby TIER0 and TIER1 logical router. Port can be
            connected to VLAN or overlay logical switch. Unlike downlink port
            it does not participate in distributed routing and hosted on all
            edge cluster members associated with logical router. Stateful
            services can be applied on this port.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  logical_router_id: :class:`str` or ``None``
        :param logical_router_id: Identifier for logical router on which this port is created
        :type  service_bindings: :class:`list` of :class:`ServiceBinding` or ``None``
        :param service_bindings: Service Bindings
        """
        self.edge_cluster_member_index = edge_cluster_member_index
        self.linked_logical_switch_port_id = linked_logical_switch_port_id
        self.mac_address = mac_address
        self.mtu = mtu
        self.ndra_prefix_config = ndra_prefix_config
        self.ndra_profile_id = ndra_profile_id
        self.pim_config = pim_config
        self.subnets = subnets
        self.urpf_mode = urpf_mode
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        self.logical_router_id = logical_router_id
        self.service_bindings = service_bindings
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

LogicalRouterUpLinkPort._set_binding_type(type.StructType(
    'com.vmware.nsx.model.logical_router_up_link_port', {
        'edge_cluster_member_index': type.OptionalType(type.ListType(type.IntegerType())),
        'linked_logical_switch_port_id': type.OptionalType(type.ReferenceType(__name__, 'ResourceReference')),
        'mac_address': type.OptionalType(type.StringType()),
        'mtu': type.OptionalType(type.IntegerType()),
        'ndra_prefix_config': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NDRAPrefixConfig'))),
        'ndra_profile_id': type.OptionalType(type.StringType()),
        'pim_config': type.OptionalType(type.ReferenceType(__name__, 'InterfacePimConfig')),
        'subnets': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IPSubnet'))),
        'urpf_mode': type.OptionalType(type.StringType()),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'logical_router_id': type.OptionalType(type.StringType()),
        'service_bindings': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ServiceBinding'))),
    },
    LogicalRouterUpLinkPort,
    False,
    None))



class LogicalServiceRouterClusterState(VapiStruct):
    """
    This holds the state of Service Router. If there are errors in realizing SR
    outside of MP, it gives details of the components and specific errors.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATE_PENDING = "pending"
    """


    """
    STATE_IN_PROGRESS = "in_progress"
    """


    """
    STATE_SUCCESS = "success"
    """


    """
    STATE_FAILED = "failed"
    """


    """
    STATE_PARTIAL_SUCCESS = "partial_success"
    """


    """
    STATE_ORPHANED = "orphaned"
    """


    """
    STATE_UNKNOWN = "unknown"
    """


    """
    STATE_ERROR = "error"
    """


    """
    STATE_IN_SYNC = "in_sync"
    """


    """
    STATE_NOT_AVAILABLE = "NOT_AVAILABLE"
    """


    """
    STATE_VM_DEPLOYMENT_QUEUED = "VM_DEPLOYMENT_QUEUED"
    """


    """
    STATE_VM_DEPLOYMENT_IN_PROGRESS = "VM_DEPLOYMENT_IN_PROGRESS"
    """


    """
    STATE_VM_DEPLOYMENT_FAILED = "VM_DEPLOYMENT_FAILED"
    """


    """
    STATE_VM_POWER_ON_IN_PROGRESS = "VM_POWER_ON_IN_PROGRESS"
    """


    """
    STATE_VM_POWER_ON_FAILED = "VM_POWER_ON_FAILED"
    """


    """
    STATE_REGISTRATION_PENDING = "REGISTRATION_PENDING"
    """


    """
    STATE_NODE_NOT_READY = "NODE_NOT_READY"
    """


    """
    STATE_NODE_READY = "NODE_READY"
    """


    """
    STATE_VM_POWER_OFF_IN_PROGRESS = "VM_POWER_OFF_IN_PROGRESS"
    """


    """
    STATE_VM_POWER_OFF_FAILED = "VM_POWER_OFF_FAILED"
    """


    """
    STATE_VM_UNDEPLOY_IN_PROGRESS = "VM_UNDEPLOY_IN_PROGRESS"
    """


    """
    STATE_VM_UNDEPLOY_FAILED = "VM_UNDEPLOY_FAILED"
    """


    """
    STATE_VM_UNDEPLOY_SUCCESSFUL = "VM_UNDEPLOY_SUCCESSFUL"
    """


    """
    STATE_EDGE_CONFIG_ERROR = "EDGE_CONFIG_ERROR"
    """


    """
    STATE_VM_DEPLOYMENT_RESTARTED = "VM_DEPLOYMENT_RESTARTED"
    """


    """
    STATE_REGISTRATION_FAILED = "REGISTRATION_FAILED"
    """


    """
    STATE_TRANSPORT_NODE_SYNC_PENDING = "TRANSPORT_NODE_SYNC_PENDING"
    """


    """
    STATE_TRANSPORT_NODE_CONFIGURATION_MISSING = "TRANSPORT_NODE_CONFIGURATION_MISSING"
    """


    """
    STATE_EDGE_HARDWARE_NOT_SUPPORTED = "EDGE_HARDWARE_NOT_SUPPORTED"
    """


    """
    STATE_MULTIPLE_OVERLAY_TZS_NOT_SUPPORTED = "MULTIPLE_OVERLAY_TZS_NOT_SUPPORTED"
    """


    """
    STATE_TN_OVERLAY_TZ_IN_USE_BY_EDGE_CLUSTER = "TN_OVERLAY_TZ_IN_USE_BY_EDGE_CLUSTER"
    """


    """
    STATE_TZ_ENDPOINTS_NOT_SPECIFIED = "TZ_ENDPOINTS_NOT_SPECIFIED"
    """


    """
    STATE_NO_PNIC_PREPARED_IN_EDGE = "NO_PNIC_PREPARED_IN_EDGE"
    """


    """
    STATE_APPLIANCE_INTERNAL_ERROR = "APPLIANCE_INTERNAL_ERROR"
    """


    """
    STATE_VTEP_DHCP_NOT_SUPPORTED = "VTEP_DHCP_NOT_SUPPORTED"
    """


    """
    STATE_UNSUPPORTED_HOST_SWITCH_PROFILE = "UNSUPPORTED_HOST_SWITCH_PROFILE"
    """


    """
    STATE_UPLINK_HOST_SWITCH_PROFILE_NOT_SPECIFIED = "UPLINK_HOST_SWITCH_PROFILE_NOT_SPECIFIED"
    """


    """
    STATE_HOSTSWITCH_PROFILE_NOT_FOUND = "HOSTSWITCH_PROFILE_NOT_FOUND"
    """


    """
    STATE_LLDP_SEND_ENABLED_NOT_SUPPORTED = "LLDP_SEND_ENABLED_NOT_SUPPORTED"
    """


    """
    STATE_UNSUPPORTED_NAMED_TEAMING_POLICY = "UNSUPPORTED_NAMED_TEAMING_POLICY"
    """


    """
    STATE_LBSRCID_NOT_SUPPORTED_FOR_EDGE_VM = "LBSRCID_NOT_SUPPORTED_FOR_EDGE_VM"
    """


    """
    STATE_LACP_NOT_SUPPORTED_FOR_EDGE_VM = "LACP_NOT_SUPPORTED_FOR_EDGE_VM"
    """


    """
    STATE_STANDBY_UPLINKS_NOT_SUPPORTED_FOR_EDGE_VM = "STANDBY_UPLINKS_NOT_SUPPORTED_FOR_EDGE_VM"
    """


    """
    STATE_MULTIPLE_ACTIVE_UPLINKS_NOT_SUPPORTED_FOR_EDGE = "MULTIPLE_ACTIVE_UPLINKS_NOT_SUPPORTED_FOR_EDGE"
    """


    """
    STATE_UNSUPPORTED_LACP_LB_ALGO_FOR_NODE = "UNSUPPORTED_LACP_LB_ALGO_FOR_NODE"
    """


    """
    STATE_EDGE_NODE_VERSION_NOT_SUPPORTED = "EDGE_NODE_VERSION_NOT_SUPPORTED"
    """


    """
    STATE_NO_PNIC_SPECIFIED_IN_TN = "NO_PNIC_SPECIFIED_IN_TN"
    """


    """
    STATE_INVALID_PNIC_DEVICE_NAME = "INVALID_PNIC_DEVICE_NAME"
    """


    """
    STATE_TRANSPORT_NODE_READY = "TRANSPORT_NODE_READY"
    """


    """
    STATE_VM_NETWORK_EDIT_PENDING = "VM_NETWORK_EDIT_PENDING"
    """


    """
    STATE_UNSUPPORTED_DEFAULT_TEAMING_POLICY = "UNSUPPORTED_DEFAULT_TEAMING_POLICY"
    """


    """
    STATE_MPA_DISCONNECTED = "MPA_DISCONNECTED"
    """


    """
    STATE_VM_RENAME_PENDING = "VM_RENAME_PENDING"
    """


    """
    STATE_VM_CONFIG_EDIT_PENDING = "VM_CONFIG_EDIT_PENDING"
    """


    """
    STATE_VM_NETWORK_EDIT_FAILED = "VM_NETWORK_EDIT_FAILED"
    """


    """
    STATE_VM_RENAME_FAILED = "VM_RENAME_FAILED"
    """


    """
    STATE_VM_CONFIG_EDIT_FAILED = "VM_CONFIG_EDIT_FAILED"
    """


    """
    STATE_VM_CONFIG_DISCREPANCY = "VM_CONFIG_DISCREPANCY"
    """


    """
    STATE_VM_NODE_REFRESH_FAILED = "VM_NODE_REFRESH_FAILED"
    """


    """
    STATE_VM_PLACEMENT_REFRESH_FAILED = "VM_PLACEMENT_REFRESH_FAILED"
    """


    """
    STATE_REGISTRATION_TIMEDOUT = "REGISTRATION_TIMEDOUT"
    """


    """



    _canonical_to_pep_names = {
                            'details': 'details',
                            'failure_code': 'failure_code',
                            'failure_message': 'failure_message',
                            'state': 'state',
                            'pending_change_list': 'pending_change_list',
                            }

    def __init__(self,
                 details=None,
                 failure_code=None,
                 failure_message=None,
                 state=None,
                 pending_change_list=None,
                ):
        """
        :type  details: :class:`list` of :class:`ConfigurationStateElement` or ``None``
        :param details: Array of configuration state of various sub systems
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  failure_code: :class:`long` or ``None``
        :param failure_code: Error code format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  failure_message: :class:`str` or ``None``
        :param failure_message: Error message in case of failure
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  state: :class:`str` or ``None``
        :param state: Possible values are: 
            
            * :attr:`LogicalServiceRouterClusterState.STATE_PENDING`
            * :attr:`LogicalServiceRouterClusterState.STATE_IN_PROGRESS`
            * :attr:`LogicalServiceRouterClusterState.STATE_SUCCESS`
            * :attr:`LogicalServiceRouterClusterState.STATE_FAILED`
            * :attr:`LogicalServiceRouterClusterState.STATE_PARTIAL_SUCCESS`
            * :attr:`LogicalServiceRouterClusterState.STATE_ORPHANED`
            * :attr:`LogicalServiceRouterClusterState.STATE_UNKNOWN`
            * :attr:`LogicalServiceRouterClusterState.STATE_ERROR`
            * :attr:`LogicalServiceRouterClusterState.STATE_IN_SYNC`
            * :attr:`LogicalServiceRouterClusterState.STATE_NOT_AVAILABLE`
            *
              :attr:`LogicalServiceRouterClusterState.STATE_VM_DEPLOYMENT_QUEUED`
            *
              :attr:`LogicalServiceRouterClusterState.STATE_VM_DEPLOYMENT_IN_PROGRESS`
            *
              :attr:`LogicalServiceRouterClusterState.STATE_VM_DEPLOYMENT_FAILED`
            *
              :attr:`LogicalServiceRouterClusterState.STATE_VM_POWER_ON_IN_PROGRESS`
            * :attr:`LogicalServiceRouterClusterState.STATE_VM_POWER_ON_FAILED`
            *
              :attr:`LogicalServiceRouterClusterState.STATE_REGISTRATION_PENDING`
            * :attr:`LogicalServiceRouterClusterState.STATE_NODE_NOT_READY`
            * :attr:`LogicalServiceRouterClusterState.STATE_NODE_READY`
            *
              :attr:`LogicalServiceRouterClusterState.STATE_VM_POWER_OFF_IN_PROGRESS`
            *
              :attr:`LogicalServiceRouterClusterState.STATE_VM_POWER_OFF_FAILED`
            *
              :attr:`LogicalServiceRouterClusterState.STATE_VM_UNDEPLOY_IN_PROGRESS`
            * :attr:`LogicalServiceRouterClusterState.STATE_VM_UNDEPLOY_FAILED`
            *
              :attr:`LogicalServiceRouterClusterState.STATE_VM_UNDEPLOY_SUCCESSFUL`
            * :attr:`LogicalServiceRouterClusterState.STATE_EDGE_CONFIG_ERROR`
            *
              :attr:`LogicalServiceRouterClusterState.STATE_VM_DEPLOYMENT_RESTARTED`
            *
              :attr:`LogicalServiceRouterClusterState.STATE_REGISTRATION_FAILED`
            *
              :attr:`LogicalServiceRouterClusterState.STATE_TRANSPORT_NODE_SYNC_PENDING`
            *
              :attr:`LogicalServiceRouterClusterState.STATE_TRANSPORT_NODE_CONFIGURATION_MISSING`
            *
              :attr:`LogicalServiceRouterClusterState.STATE_EDGE_HARDWARE_NOT_SUPPORTED`
            *
              :attr:`LogicalServiceRouterClusterState.STATE_MULTIPLE_OVERLAY_TZS_NOT_SUPPORTED`
            *
              :attr:`LogicalServiceRouterClusterState.STATE_TN_OVERLAY_TZ_IN_USE_BY_EDGE_CLUSTER`
            *
              :attr:`LogicalServiceRouterClusterState.STATE_TZ_ENDPOINTS_NOT_SPECIFIED`
            *
              :attr:`LogicalServiceRouterClusterState.STATE_NO_PNIC_PREPARED_IN_EDGE`
            *
              :attr:`LogicalServiceRouterClusterState.STATE_APPLIANCE_INTERNAL_ERROR`
            *
              :attr:`LogicalServiceRouterClusterState.STATE_VTEP_DHCP_NOT_SUPPORTED`
            *
              :attr:`LogicalServiceRouterClusterState.STATE_UNSUPPORTED_HOST_SWITCH_PROFILE`
            *
              :attr:`LogicalServiceRouterClusterState.STATE_UPLINK_HOST_SWITCH_PROFILE_NOT_SPECIFIED`
            *
              :attr:`LogicalServiceRouterClusterState.STATE_HOSTSWITCH_PROFILE_NOT_FOUND`
            *
              :attr:`LogicalServiceRouterClusterState.STATE_LLDP_SEND_ENABLED_NOT_SUPPORTED`
            *
              :attr:`LogicalServiceRouterClusterState.STATE_UNSUPPORTED_NAMED_TEAMING_POLICY`
            *
              :attr:`LogicalServiceRouterClusterState.STATE_LBSRCID_NOT_SUPPORTED_FOR_EDGE_VM`
            *
              :attr:`LogicalServiceRouterClusterState.STATE_LACP_NOT_SUPPORTED_FOR_EDGE_VM`
            *
              :attr:`LogicalServiceRouterClusterState.STATE_STANDBY_UPLINKS_NOT_SUPPORTED_FOR_EDGE_VM`
            *
              :attr:`LogicalServiceRouterClusterState.STATE_MULTIPLE_ACTIVE_UPLINKS_NOT_SUPPORTED_FOR_EDGE`
            *
              :attr:`LogicalServiceRouterClusterState.STATE_UNSUPPORTED_LACP_LB_ALGO_FOR_NODE`
            *
              :attr:`LogicalServiceRouterClusterState.STATE_EDGE_NODE_VERSION_NOT_SUPPORTED`
            *
              :attr:`LogicalServiceRouterClusterState.STATE_NO_PNIC_SPECIFIED_IN_TN`
            *
              :attr:`LogicalServiceRouterClusterState.STATE_INVALID_PNIC_DEVICE_NAME`
            *
              :attr:`LogicalServiceRouterClusterState.STATE_TRANSPORT_NODE_READY`
            *
              :attr:`LogicalServiceRouterClusterState.STATE_VM_NETWORK_EDIT_PENDING`
            *
              :attr:`LogicalServiceRouterClusterState.STATE_UNSUPPORTED_DEFAULT_TEAMING_POLICY`
            * :attr:`LogicalServiceRouterClusterState.STATE_MPA_DISCONNECTED`
            * :attr:`LogicalServiceRouterClusterState.STATE_VM_RENAME_PENDING`
            *
              :attr:`LogicalServiceRouterClusterState.STATE_VM_CONFIG_EDIT_PENDING`
            *
              :attr:`LogicalServiceRouterClusterState.STATE_VM_NETWORK_EDIT_FAILED`
            * :attr:`LogicalServiceRouterClusterState.STATE_VM_RENAME_FAILED`
            *
              :attr:`LogicalServiceRouterClusterState.STATE_VM_CONFIG_EDIT_FAILED`
            *
              :attr:`LogicalServiceRouterClusterState.STATE_VM_CONFIG_DISCREPANCY`
            *
              :attr:`LogicalServiceRouterClusterState.STATE_VM_NODE_REFRESH_FAILED`
            *
              :attr:`LogicalServiceRouterClusterState.STATE_VM_PLACEMENT_REFRESH_FAILED`
            *
              :attr:`LogicalServiceRouterClusterState.STATE_REGISTRATION_TIMEDOUT`
            
            Gives details of state of desired configuration. Additional enums
            with more details on progress/success/error states are sent for
            edge node. The success states are NODE_READY and
            TRANSPORT_NODE_READY, pending states are {VM_DEPLOYMENT_QUEUED,
            VM_DEPLOYMENT_IN_PROGRESS, REGISTRATION_PENDING} and other values
            indicate failures. \"in_sync\" state indicates that the desired
            configuration has been received by the host to which it applies,
            but is not yet in effect. When the configuration is actually in
            effect, the state will change to \"success\". Please note, failed
            state is deprecated.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  pending_change_list: :class:`list` of :class:`str` or ``None``
        :param pending_change_list: Request identifier of the API which modified the entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.details = details
        self.failure_code = failure_code
        self.failure_message = failure_message
        self.state = state
        self.pending_change_list = pending_change_list
        VapiStruct.__init__(self)


LogicalServiceRouterClusterState._set_binding_type(type.StructType(
    'com.vmware.nsx.model.logical_service_router_cluster_state', {
        'details': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ConfigurationStateElement'))),
        'failure_code': type.OptionalType(type.IntegerType()),
        'failure_message': type.OptionalType(type.StringType()),
        'state': type.OptionalType(type.StringType()),
        'pending_change_list': type.OptionalType(type.ListType(type.StringType())),
    },
    LogicalServiceRouterClusterState,
    False,
    None))



class LogicalSwitch(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    ADMIN_STATE_UP = "UP"
    """


    """
    ADMIN_STATE_DOWN = "DOWN"
    """


    """
    REPLICATION_MODE_MTEP = "MTEP"
    """


    """
    REPLICATION_MODE_SOURCE = "SOURCE"
    """


    """
    SWITCH_TYPE_DEFAULT = "DEFAULT"
    """


    """
    SWITCH_TYPE_SERVICE_PLANE = "SERVICE_PLANE"
    """


    """
    SWITCH_TYPE_DHCP_RELAY = "DHCP_RELAY"
    """


    """
    SWITCH_TYPE_GLOBAL = "GLOBAL"
    """


    """
    SWITCH_TYPE_INTER_ROUTER = "INTER_ROUTER"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'address_bindings': 'address_bindings',
                            'admin_state': 'admin_state',
                            'extra_configs': 'extra_configs',
                            'global_vni': 'global_vni',
                            'hybrid': 'hybrid',
                            'ip_pool_id': 'ip_pool_id',
                            'mac_pool_id': 'mac_pool_id',
                            'replication_mode': 'replication_mode',
                            'span': 'span',
                            'switch_type': 'switch_type',
                            'switching_profile_ids': 'switching_profile_ids',
                            'transport_zone_id': 'transport_zone_id',
                            'uplink_teaming_policy_name': 'uplink_teaming_policy_name',
                            'vlan': 'vlan',
                            'vlan_trunk_spec': 'vlan_trunk_spec',
                            'vni': 'vni',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 address_bindings=None,
                 admin_state=None,
                 extra_configs=None,
                 global_vni=None,
                 hybrid=None,
                 ip_pool_id=None,
                 mac_pool_id=None,
                 replication_mode=None,
                 span=None,
                 switch_type=None,
                 switching_profile_ids=None,
                 transport_zone_id=None,
                 uplink_teaming_policy_name=None,
                 vlan=None,
                 vlan_trunk_spec=None,
                 vni=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  address_bindings: :class:`list` of :class:`PacketAddressClassifier` or ``None``
        :param address_bindings: Address bindings for the Logical switch
        :type  admin_state: :class:`str` or ``None``
        :param admin_state: Possible values are: 
            
            * :attr:`LogicalSwitch.ADMIN_STATE_UP`
            * :attr:`LogicalSwitch.ADMIN_STATE_DOWN`
            
             Represents Desired state of the Logical Switch
        :type  extra_configs: :class:`list` of :class:`ExtraConfig` or ``None``
        :param extra_configs: This property could be used for vendor specific configuration in
            key value string pairs, the setting in extra_configs will be
            automatically inheritted by logical ports in the logical switch.
        :type  global_vni: :class:`long` or ``None``
        :param global_vni: The VNI is used for intersite traffic and the global logical switch
            ID. The global VNI pool is agnostic of the local VNI pool, and
            there is no need to have an exclusive VNI range. For example, VNI x
            can be the global VNI for logical switch B and the local VNI for
            logical switch A. format: int32
        :type  hybrid: :class:`bool` or ``None``
        :param hybrid: If this flag is set to true, then all the logical switch ports
            attached to this logical switch will behave in a hybrid fashion.
            The hybrid logical switch port indicates to NSX that the VM intends
            to operate in underlay mode, but retains the ability to forward
            egress traffic to the NSX overlay network. This flag can be enabled
            only for the logical switches in the overlay type transport zone
            which has host switch mode as STANDARD and also has either
            CrossCloud or CloudScope tag scopes. Only the NSX public cloud
            gateway (PCG) uses this flag, other host agents like ESX, KVM and
            Edge will ignore it. This property cannot be modified once the
            logical switch is created.
        :type  ip_pool_id: :class:`str` or ``None``
        :param ip_pool_id: IP pool id that associated with a LogicalSwitch.
        :type  mac_pool_id: :class:`str` or ``None``
        :param mac_pool_id: Mac pool id that associated with a LogicalSwitch.
        :type  replication_mode: :class:`str` or ``None``
        :param replication_mode: Possible values are: 
            
            * :attr:`LogicalSwitch.REPLICATION_MODE_MTEP`
            * :attr:`LogicalSwitch.REPLICATION_MODE_SOURCE`
            
             Replication mode of the Logical Switch
        :type  span: :class:`list` of :class:`str` or ``None``
        :param span: Each manager ID represents the NSX Local Manager the logical switch
            connects. This will be populated by the manager.
        :type  switch_type: :class:`str` or ``None``
        :param switch_type: Possible values are: 
            
            * :attr:`LogicalSwitch.SWITCH_TYPE_DEFAULT`
            * :attr:`LogicalSwitch.SWITCH_TYPE_SERVICE_PLANE`
            * :attr:`LogicalSwitch.SWITCH_TYPE_DHCP_RELAY`
            * :attr:`LogicalSwitch.SWITCH_TYPE_GLOBAL`
            * :attr:`LogicalSwitch.SWITCH_TYPE_INTER_ROUTER`
            
            This field indicates purpose of a LogicalSwitch. It is set by
            manager internally or user can provide this field. If not set,
            DEFAULT type is assigned. NSX components can use this field to
            create LogicalSwitch that provides component specific
            functionality. DEFAULT type LogicalSwitches are created for basic
            L2 connectivity by API users. SERVICE_PLANE type LogicalSwitches
            are system created service plane LogicalSwitches for Service
            Insertion service. User can not create SERVICE_PLANE type of
            LogicalSwitch. DHCP_RELAY type LogicalSwitches are created by
            external user like Policy with special permissions or by system and
            will be treated as internal LogicalSwitches. Such LogicalSwitch
            will not be exposed to vSphere user. GLOBAL type LogicalSwitches
            are created to span multiple NSX domains to connect multiple remote
            sites. INTER_ROUTER type LogicalSwitches are policy-created
            LogicalSwitches which provide inter-router connectivity
        :type  switching_profile_ids: :class:`list` of :class:`SwitchingProfileTypeIdEntry` or ``None``
        :param switching_profile_ids: 
        :type  transport_zone_id: :class:`str` or ``None``
        :param transport_zone_id: Id of the TransportZone to which this LogicalSwitch is associated
        :type  uplink_teaming_policy_name: :class:`str` or ``None``
        :param uplink_teaming_policy_name: This name has to be one of the switching uplink teaming policy
            names listed inside the logical switch's TransportZone. If this
            field is not specified, the logical switch will not have a teaming
            policy associated with it and the host switch's default teaming
            policy will be used.
        :type  vlan: :class:`long` or ``None``
        :param vlan: This property is dedicated to VLAN based network, to set VLAN of
            logical network. It is mutually exclusive with 'vlan_trunk_spec'.
            format: int64
        :type  vlan_trunk_spec: :class:`VlanTrunkSpec` or ``None``
        :param vlan_trunk_spec: This property is used for VLAN trunk specification of logical
            switch. It's mutually exclusive with 'vlan'. Also it could be set
            to do guest VLAN tagging in overlay network.
        :type  vni: :class:`long` or ``None``
        :param vni: Only for OVERLAY network. A VNI will be auto-allocated from the
            default VNI pool if not given; otherwise the given VNI has to be
            inside the default pool and not used by any other LogicalSwitch.
            format: int32
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.address_bindings = address_bindings
        self.admin_state = admin_state
        self.extra_configs = extra_configs
        self.global_vni = global_vni
        self.hybrid = hybrid
        self.ip_pool_id = ip_pool_id
        self.mac_pool_id = mac_pool_id
        self.replication_mode = replication_mode
        self.span = span
        self.switch_type = switch_type
        self.switching_profile_ids = switching_profile_ids
        self.transport_zone_id = transport_zone_id
        self.uplink_teaming_policy_name = uplink_teaming_policy_name
        self.vlan = vlan
        self.vlan_trunk_spec = vlan_trunk_spec
        self.vni = vni
        VapiStruct.__init__(self)


LogicalSwitch._set_binding_type(type.StructType(
    'com.vmware.nsx.model.logical_switch', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'address_bindings': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'PacketAddressClassifier'))),
        'admin_state': type.OptionalType(type.StringType()),
        'extra_configs': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ExtraConfig'))),
        'global_vni': type.OptionalType(type.IntegerType()),
        'hybrid': type.OptionalType(type.BooleanType()),
        'ip_pool_id': type.OptionalType(type.StringType()),
        'mac_pool_id': type.OptionalType(type.StringType()),
        'replication_mode': type.OptionalType(type.StringType()),
        'span': type.OptionalType(type.ListType(type.StringType())),
        'switch_type': type.OptionalType(type.StringType()),
        'switching_profile_ids': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'SwitchingProfileTypeIdEntry'))),
        'transport_zone_id': type.OptionalType(type.StringType()),
        'uplink_teaming_policy_name': type.OptionalType(type.StringType()),
        'vlan': type.OptionalType(type.IntegerType()),
        'vlan_trunk_spec': type.OptionalType(type.ReferenceType(__name__, 'VlanTrunkSpec')),
        'vni': type.OptionalType(type.IntegerType()),
    },
    LogicalSwitch,
    False,
    None))



class LogicalSwitchListResult(VapiStruct):
    """
    Logical Switch queries result

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`LogicalSwitch` or ``None``
        :param results: Logical Switch Results
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


LogicalSwitchListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.logical_switch_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'LogicalSwitch'))),
    },
    LogicalSwitchListResult,
    False,
    None))



class LogicalSwitchMirrorSource(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LogicalSwitchMirrorSource"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'switch_id': 'switch_id',
                            'resource_type': 'resource_type',
                            }

    def __init__(self,
                 switch_id=None,
                 resource_type='LogicalSwitchMirrorSource',
                ):
        """
        :type  switch_id: :class:`str` or ``None``
        :param switch_id: Please note as logical port attached with vmk interface is
            unsupported as mirror source, traffic from those ports on source
            logical switch will not be mirrored.
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`MirrorSource.RESOURCE_TYPE_LOGICALPORTMIRRORSOURCE`
            * :attr:`MirrorSource.RESOURCE_TYPE_PNICMIRRORSOURCE`
            * :attr:`MirrorSource.RESOURCE_TYPE_VLANMIRRORSOURCE`
            * :attr:`MirrorSource.RESOURCE_TYPE_LOGICALSWITCHMIRRORSOURCE`
            
             Resource types of mirror source
        """
        self.switch_id = switch_id
        self._resource_type = resource_type
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

LogicalSwitchMirrorSource._set_binding_type(type.StructType(
    'com.vmware.nsx.model.logical_switch_mirror_source', {
        'switch_id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
    },
    LogicalSwitchMirrorSource,
    False,
    None))



class LogicalSwitchState(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATE_PENDING = "pending"
    """


    """
    STATE_IN_PROGRESS = "in_progress"
    """


    """
    STATE_SUCCESS = "success"
    """


    """
    STATE_FAILED = "failed"
    """


    """
    STATE_PARTIAL_SUCCESS = "partial_success"
    """


    """
    STATE_ORPHANED = "orphaned"
    """


    """
    STATE_UNKNOWN = "unknown"
    """


    """
    STATE_ERROR = "error"
    """


    """
    STATE_IN_SYNC = "in_sync"
    """


    """
    STATE_NOT_AVAILABLE = "NOT_AVAILABLE"
    """


    """
    STATE_VM_DEPLOYMENT_QUEUED = "VM_DEPLOYMENT_QUEUED"
    """


    """
    STATE_VM_DEPLOYMENT_IN_PROGRESS = "VM_DEPLOYMENT_IN_PROGRESS"
    """


    """
    STATE_VM_DEPLOYMENT_FAILED = "VM_DEPLOYMENT_FAILED"
    """


    """
    STATE_VM_POWER_ON_IN_PROGRESS = "VM_POWER_ON_IN_PROGRESS"
    """


    """
    STATE_VM_POWER_ON_FAILED = "VM_POWER_ON_FAILED"
    """


    """
    STATE_REGISTRATION_PENDING = "REGISTRATION_PENDING"
    """


    """
    STATE_NODE_NOT_READY = "NODE_NOT_READY"
    """


    """
    STATE_NODE_READY = "NODE_READY"
    """


    """
    STATE_VM_POWER_OFF_IN_PROGRESS = "VM_POWER_OFF_IN_PROGRESS"
    """


    """
    STATE_VM_POWER_OFF_FAILED = "VM_POWER_OFF_FAILED"
    """


    """
    STATE_VM_UNDEPLOY_IN_PROGRESS = "VM_UNDEPLOY_IN_PROGRESS"
    """


    """
    STATE_VM_UNDEPLOY_FAILED = "VM_UNDEPLOY_FAILED"
    """


    """
    STATE_VM_UNDEPLOY_SUCCESSFUL = "VM_UNDEPLOY_SUCCESSFUL"
    """


    """
    STATE_EDGE_CONFIG_ERROR = "EDGE_CONFIG_ERROR"
    """


    """
    STATE_VM_DEPLOYMENT_RESTARTED = "VM_DEPLOYMENT_RESTARTED"
    """


    """
    STATE_REGISTRATION_FAILED = "REGISTRATION_FAILED"
    """


    """
    STATE_TRANSPORT_NODE_SYNC_PENDING = "TRANSPORT_NODE_SYNC_PENDING"
    """


    """
    STATE_TRANSPORT_NODE_CONFIGURATION_MISSING = "TRANSPORT_NODE_CONFIGURATION_MISSING"
    """


    """
    STATE_EDGE_HARDWARE_NOT_SUPPORTED = "EDGE_HARDWARE_NOT_SUPPORTED"
    """


    """
    STATE_MULTIPLE_OVERLAY_TZS_NOT_SUPPORTED = "MULTIPLE_OVERLAY_TZS_NOT_SUPPORTED"
    """


    """
    STATE_TN_OVERLAY_TZ_IN_USE_BY_EDGE_CLUSTER = "TN_OVERLAY_TZ_IN_USE_BY_EDGE_CLUSTER"
    """


    """
    STATE_TZ_ENDPOINTS_NOT_SPECIFIED = "TZ_ENDPOINTS_NOT_SPECIFIED"
    """


    """
    STATE_NO_PNIC_PREPARED_IN_EDGE = "NO_PNIC_PREPARED_IN_EDGE"
    """


    """
    STATE_APPLIANCE_INTERNAL_ERROR = "APPLIANCE_INTERNAL_ERROR"
    """


    """
    STATE_VTEP_DHCP_NOT_SUPPORTED = "VTEP_DHCP_NOT_SUPPORTED"
    """


    """
    STATE_UNSUPPORTED_HOST_SWITCH_PROFILE = "UNSUPPORTED_HOST_SWITCH_PROFILE"
    """


    """
    STATE_UPLINK_HOST_SWITCH_PROFILE_NOT_SPECIFIED = "UPLINK_HOST_SWITCH_PROFILE_NOT_SPECIFIED"
    """


    """
    STATE_HOSTSWITCH_PROFILE_NOT_FOUND = "HOSTSWITCH_PROFILE_NOT_FOUND"
    """


    """
    STATE_LLDP_SEND_ENABLED_NOT_SUPPORTED = "LLDP_SEND_ENABLED_NOT_SUPPORTED"
    """


    """
    STATE_UNSUPPORTED_NAMED_TEAMING_POLICY = "UNSUPPORTED_NAMED_TEAMING_POLICY"
    """


    """
    STATE_LBSRCID_NOT_SUPPORTED_FOR_EDGE_VM = "LBSRCID_NOT_SUPPORTED_FOR_EDGE_VM"
    """


    """
    STATE_LACP_NOT_SUPPORTED_FOR_EDGE_VM = "LACP_NOT_SUPPORTED_FOR_EDGE_VM"
    """


    """
    STATE_STANDBY_UPLINKS_NOT_SUPPORTED_FOR_EDGE_VM = "STANDBY_UPLINKS_NOT_SUPPORTED_FOR_EDGE_VM"
    """


    """
    STATE_MULTIPLE_ACTIVE_UPLINKS_NOT_SUPPORTED_FOR_EDGE = "MULTIPLE_ACTIVE_UPLINKS_NOT_SUPPORTED_FOR_EDGE"
    """


    """
    STATE_UNSUPPORTED_LACP_LB_ALGO_FOR_NODE = "UNSUPPORTED_LACP_LB_ALGO_FOR_NODE"
    """


    """
    STATE_EDGE_NODE_VERSION_NOT_SUPPORTED = "EDGE_NODE_VERSION_NOT_SUPPORTED"
    """


    """
    STATE_NO_PNIC_SPECIFIED_IN_TN = "NO_PNIC_SPECIFIED_IN_TN"
    """


    """
    STATE_INVALID_PNIC_DEVICE_NAME = "INVALID_PNIC_DEVICE_NAME"
    """


    """
    STATE_TRANSPORT_NODE_READY = "TRANSPORT_NODE_READY"
    """


    """
    STATE_VM_NETWORK_EDIT_PENDING = "VM_NETWORK_EDIT_PENDING"
    """


    """
    STATE_UNSUPPORTED_DEFAULT_TEAMING_POLICY = "UNSUPPORTED_DEFAULT_TEAMING_POLICY"
    """


    """
    STATE_MPA_DISCONNECTED = "MPA_DISCONNECTED"
    """


    """
    STATE_VM_RENAME_PENDING = "VM_RENAME_PENDING"
    """


    """
    STATE_VM_CONFIG_EDIT_PENDING = "VM_CONFIG_EDIT_PENDING"
    """


    """
    STATE_VM_NETWORK_EDIT_FAILED = "VM_NETWORK_EDIT_FAILED"
    """


    """
    STATE_VM_RENAME_FAILED = "VM_RENAME_FAILED"
    """


    """
    STATE_VM_CONFIG_EDIT_FAILED = "VM_CONFIG_EDIT_FAILED"
    """


    """
    STATE_VM_CONFIG_DISCREPANCY = "VM_CONFIG_DISCREPANCY"
    """


    """
    STATE_VM_NODE_REFRESH_FAILED = "VM_NODE_REFRESH_FAILED"
    """


    """
    STATE_VM_PLACEMENT_REFRESH_FAILED = "VM_PLACEMENT_REFRESH_FAILED"
    """


    """
    STATE_REGISTRATION_TIMEDOUT = "REGISTRATION_TIMEDOUT"
    """


    """



    _canonical_to_pep_names = {
                            'details': 'details',
                            'failure_code': 'failure_code',
                            'failure_message': 'failure_message',
                            'state': 'state',
                            'logical_switch_id': 'logical_switch_id',
                            }

    def __init__(self,
                 details=None,
                 failure_code=None,
                 failure_message=None,
                 state=None,
                 logical_switch_id=None,
                ):
        """
        :type  details: :class:`list` of :class:`ConfigurationStateElement` or ``None``
        :param details: Array of configuration state of various sub systems
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  failure_code: :class:`long` or ``None``
        :param failure_code: Error code format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  failure_message: :class:`str` or ``None``
        :param failure_message: Error message in case of failure
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  state: :class:`str` or ``None``
        :param state: Possible values are: 
            
            * :attr:`LogicalSwitchState.STATE_PENDING`
            * :attr:`LogicalSwitchState.STATE_IN_PROGRESS`
            * :attr:`LogicalSwitchState.STATE_SUCCESS`
            * :attr:`LogicalSwitchState.STATE_FAILED`
            * :attr:`LogicalSwitchState.STATE_PARTIAL_SUCCESS`
            * :attr:`LogicalSwitchState.STATE_ORPHANED`
            * :attr:`LogicalSwitchState.STATE_UNKNOWN`
            * :attr:`LogicalSwitchState.STATE_ERROR`
            * :attr:`LogicalSwitchState.STATE_IN_SYNC`
            * :attr:`LogicalSwitchState.STATE_NOT_AVAILABLE`
            * :attr:`LogicalSwitchState.STATE_VM_DEPLOYMENT_QUEUED`
            * :attr:`LogicalSwitchState.STATE_VM_DEPLOYMENT_IN_PROGRESS`
            * :attr:`LogicalSwitchState.STATE_VM_DEPLOYMENT_FAILED`
            * :attr:`LogicalSwitchState.STATE_VM_POWER_ON_IN_PROGRESS`
            * :attr:`LogicalSwitchState.STATE_VM_POWER_ON_FAILED`
            * :attr:`LogicalSwitchState.STATE_REGISTRATION_PENDING`
            * :attr:`LogicalSwitchState.STATE_NODE_NOT_READY`
            * :attr:`LogicalSwitchState.STATE_NODE_READY`
            * :attr:`LogicalSwitchState.STATE_VM_POWER_OFF_IN_PROGRESS`
            * :attr:`LogicalSwitchState.STATE_VM_POWER_OFF_FAILED`
            * :attr:`LogicalSwitchState.STATE_VM_UNDEPLOY_IN_PROGRESS`
            * :attr:`LogicalSwitchState.STATE_VM_UNDEPLOY_FAILED`
            * :attr:`LogicalSwitchState.STATE_VM_UNDEPLOY_SUCCESSFUL`
            * :attr:`LogicalSwitchState.STATE_EDGE_CONFIG_ERROR`
            * :attr:`LogicalSwitchState.STATE_VM_DEPLOYMENT_RESTARTED`
            * :attr:`LogicalSwitchState.STATE_REGISTRATION_FAILED`
            * :attr:`LogicalSwitchState.STATE_TRANSPORT_NODE_SYNC_PENDING`
            *
              :attr:`LogicalSwitchState.STATE_TRANSPORT_NODE_CONFIGURATION_MISSING`
            * :attr:`LogicalSwitchState.STATE_EDGE_HARDWARE_NOT_SUPPORTED`
            *
              :attr:`LogicalSwitchState.STATE_MULTIPLE_OVERLAY_TZS_NOT_SUPPORTED`
            *
              :attr:`LogicalSwitchState.STATE_TN_OVERLAY_TZ_IN_USE_BY_EDGE_CLUSTER`
            * :attr:`LogicalSwitchState.STATE_TZ_ENDPOINTS_NOT_SPECIFIED`
            * :attr:`LogicalSwitchState.STATE_NO_PNIC_PREPARED_IN_EDGE`
            * :attr:`LogicalSwitchState.STATE_APPLIANCE_INTERNAL_ERROR`
            * :attr:`LogicalSwitchState.STATE_VTEP_DHCP_NOT_SUPPORTED`
            * :attr:`LogicalSwitchState.STATE_UNSUPPORTED_HOST_SWITCH_PROFILE`
            *
              :attr:`LogicalSwitchState.STATE_UPLINK_HOST_SWITCH_PROFILE_NOT_SPECIFIED`
            * :attr:`LogicalSwitchState.STATE_HOSTSWITCH_PROFILE_NOT_FOUND`
            * :attr:`LogicalSwitchState.STATE_LLDP_SEND_ENABLED_NOT_SUPPORTED`
            * :attr:`LogicalSwitchState.STATE_UNSUPPORTED_NAMED_TEAMING_POLICY`
            *
              :attr:`LogicalSwitchState.STATE_LBSRCID_NOT_SUPPORTED_FOR_EDGE_VM`
            * :attr:`LogicalSwitchState.STATE_LACP_NOT_SUPPORTED_FOR_EDGE_VM`
            *
              :attr:`LogicalSwitchState.STATE_STANDBY_UPLINKS_NOT_SUPPORTED_FOR_EDGE_VM`
            *
              :attr:`LogicalSwitchState.STATE_MULTIPLE_ACTIVE_UPLINKS_NOT_SUPPORTED_FOR_EDGE`
            *
              :attr:`LogicalSwitchState.STATE_UNSUPPORTED_LACP_LB_ALGO_FOR_NODE`
            * :attr:`LogicalSwitchState.STATE_EDGE_NODE_VERSION_NOT_SUPPORTED`
            * :attr:`LogicalSwitchState.STATE_NO_PNIC_SPECIFIED_IN_TN`
            * :attr:`LogicalSwitchState.STATE_INVALID_PNIC_DEVICE_NAME`
            * :attr:`LogicalSwitchState.STATE_TRANSPORT_NODE_READY`
            * :attr:`LogicalSwitchState.STATE_VM_NETWORK_EDIT_PENDING`
            *
              :attr:`LogicalSwitchState.STATE_UNSUPPORTED_DEFAULT_TEAMING_POLICY`
            * :attr:`LogicalSwitchState.STATE_MPA_DISCONNECTED`
            * :attr:`LogicalSwitchState.STATE_VM_RENAME_PENDING`
            * :attr:`LogicalSwitchState.STATE_VM_CONFIG_EDIT_PENDING`
            * :attr:`LogicalSwitchState.STATE_VM_NETWORK_EDIT_FAILED`
            * :attr:`LogicalSwitchState.STATE_VM_RENAME_FAILED`
            * :attr:`LogicalSwitchState.STATE_VM_CONFIG_EDIT_FAILED`
            * :attr:`LogicalSwitchState.STATE_VM_CONFIG_DISCREPANCY`
            * :attr:`LogicalSwitchState.STATE_VM_NODE_REFRESH_FAILED`
            * :attr:`LogicalSwitchState.STATE_VM_PLACEMENT_REFRESH_FAILED`
            * :attr:`LogicalSwitchState.STATE_REGISTRATION_TIMEDOUT`
            
            Gives details of state of desired configuration. Additional enums
            with more details on progress/success/error states are sent for
            edge node. The success states are NODE_READY and
            TRANSPORT_NODE_READY, pending states are {VM_DEPLOYMENT_QUEUED,
            VM_DEPLOYMENT_IN_PROGRESS, REGISTRATION_PENDING} and other values
            indicate failures. \"in_sync\" state indicates that the desired
            configuration has been received by the host to which it applies,
            but is not yet in effect. When the configuration is actually in
            effect, the state will change to \"success\". Please note, failed
            state is deprecated.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  logical_switch_id: :class:`str` or ``None``
        :param logical_switch_id: Id of the logical switch
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.details = details
        self.failure_code = failure_code
        self.failure_message = failure_message
        self.state = state
        self.logical_switch_id = logical_switch_id
        VapiStruct.__init__(self)


LogicalSwitchState._set_binding_type(type.StructType(
    'com.vmware.nsx.model.logical_switch_state', {
        'details': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ConfigurationStateElement'))),
        'failure_code': type.OptionalType(type.IntegerType()),
        'failure_message': type.OptionalType(type.StringType()),
        'state': type.OptionalType(type.StringType()),
        'logical_switch_id': type.OptionalType(type.StringType()),
    },
    LogicalSwitchState,
    False,
    None))



class LogicalSwitchStateListResult(VapiStruct):
    """
    Logical Switch state queries result

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`LogicalSwitchState` or ``None``
        :param results: Logical Switch State Results
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


LogicalSwitchStateListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.logical_switch_state_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'LogicalSwitchState'))),
    },
    LogicalSwitchStateListResult,
    False,
    None))



class LogicalSwitchStatistics(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'rx_bytes': 'rx_bytes',
                            'rx_packets': 'rx_packets',
                            'tx_bytes': 'tx_bytes',
                            'tx_packets': 'tx_packets',
                            'dropped_by_security_packets': 'dropped_by_security_packets',
                            'mac_learning': 'mac_learning',
                            'last_update_timestamp': 'last_update_timestamp',
                            'logical_switch_id': 'logical_switch_id',
                            }

    def __init__(self,
                 rx_bytes=None,
                 rx_packets=None,
                 tx_bytes=None,
                 tx_packets=None,
                 dropped_by_security_packets=None,
                 mac_learning=None,
                 last_update_timestamp=None,
                 logical_switch_id=None,
                ):
        """
        :type  rx_bytes: :class:`DataCounter` or ``None``
        :param rx_bytes: 
        :type  rx_packets: :class:`DataCounter` or ``None``
        :param rx_packets: 
        :type  tx_bytes: :class:`DataCounter` or ``None``
        :param tx_bytes: 
        :type  tx_packets: :class:`DataCounter` or ``None``
        :param tx_packets: 
        :type  dropped_by_security_packets: :class:`PacketsDroppedBySecurity` or ``None``
        :param dropped_by_security_packets: 
        :type  mac_learning: :class:`MacLearningCounters` or ``None``
        :param mac_learning: 
        :type  last_update_timestamp: :class:`long` or ``None``
        :param last_update_timestamp: Timestamp when the data was last updated; unset if data source has
            never updated the data. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  logical_switch_id: :class:`str` or ``None``
        :param logical_switch_id: The id of the logical Switch
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.rx_bytes = rx_bytes
        self.rx_packets = rx_packets
        self.tx_bytes = tx_bytes
        self.tx_packets = tx_packets
        self.dropped_by_security_packets = dropped_by_security_packets
        self.mac_learning = mac_learning
        self.last_update_timestamp = last_update_timestamp
        self.logical_switch_id = logical_switch_id
        VapiStruct.__init__(self)


LogicalSwitchStatistics._set_binding_type(type.StructType(
    'com.vmware.nsx.model.logical_switch_statistics', {
        'rx_bytes': type.OptionalType(type.ReferenceType(__name__, 'DataCounter')),
        'rx_packets': type.OptionalType(type.ReferenceType(__name__, 'DataCounter')),
        'tx_bytes': type.OptionalType(type.ReferenceType(__name__, 'DataCounter')),
        'tx_packets': type.OptionalType(type.ReferenceType(__name__, 'DataCounter')),
        'dropped_by_security_packets': type.OptionalType(type.ReferenceType(__name__, 'PacketsDroppedBySecurity')),
        'mac_learning': type.OptionalType(type.ReferenceType(__name__, 'MacLearningCounters')),
        'last_update_timestamp': type.OptionalType(type.IntegerType()),
        'logical_switch_id': type.OptionalType(type.StringType()),
    },
    LogicalSwitchStatistics,
    False,
    None))



class LogicalSwitchStatus(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'logical_switch_id': 'logical_switch_id',
                            'num_logical_ports': 'num_logical_ports',
                            }

    def __init__(self,
                 logical_switch_id=None,
                 num_logical_ports=None,
                ):
        """
        :type  logical_switch_id: :class:`str` or ``None``
        :param logical_switch_id: Unique ID identifying the the Logical Switch
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  num_logical_ports: :class:`long` or ``None``
        :param num_logical_ports: Count of Logical Ports belonging to this switch format: int32
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.logical_switch_id = logical_switch_id
        self.num_logical_ports = num_logical_ports
        VapiStruct.__init__(self)


LogicalSwitchStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.logical_switch_status', {
        'logical_switch_id': type.OptionalType(type.StringType()),
        'num_logical_ports': type.OptionalType(type.IntegerType()),
    },
    LogicalSwitchStatus,
    False,
    None))



class LogicalSwitchStatusSummary(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'filters': 'filters',
                            'fully_realized_switches': 'fully_realized_switches',
                            'last_update_timestamp': 'last_update_timestamp',
                            'total_switches': 'total_switches',
                            }

    def __init__(self,
                 filters=None,
                 fully_realized_switches=None,
                 last_update_timestamp=None,
                 total_switches=None,
                ):
        """
        :type  filters: :class:`list` of :class:`Filter` or ``None``
        :param filters: The filters used to find the logical switches- TransportZone id,
            LogicalSwitchProfile id or TransportType
        :type  fully_realized_switches: :class:`long` or ``None``
        :param fully_realized_switches: The number of logical switches that are realized in all transport
            nodes. format: int64
        :type  last_update_timestamp: :class:`long` or ``None``
        :param last_update_timestamp: Timestamp when the data was last updated; unset if data source has
            never updated the data. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  total_switches: :class:`long` or ``None``
        :param total_switches: The total number of logical switches. format: int64
        """
        self.filters = filters
        self.fully_realized_switches = fully_realized_switches
        self.last_update_timestamp = last_update_timestamp
        self.total_switches = total_switches
        VapiStruct.__init__(self)


LogicalSwitchStatusSummary._set_binding_type(type.StructType(
    'com.vmware.nsx.model.logical_switch_status_summary', {
        'filters': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Filter'))),
        'fully_realized_switches': type.OptionalType(type.IntegerType()),
        'last_update_timestamp': type.OptionalType(type.IntegerType()),
        'total_switches': type.OptionalType(type.IntegerType()),
    },
    LogicalSwitchStatusSummary,
    False,
    None))



class LoginCredential(VapiStruct):
    """
    Base type for various login credential types

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "LoginCredential"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'credential_type': 'credential_type',
                            }

    def __init__(self,
                 credential_type='LoginCredential',
                ):
        """
        :type  credential_type: :class:`str`
        :param credential_type: Possible values are 'UsernamePasswordLoginCredential',
            'VerifiableAsymmetricLoginCredential', 'SessionLoginCredential'.
        """
        self._credential_type = credential_type
        VapiStruct.__init__(self)

    @property
    def credential_type(self):
        """
        Return the discriminator value
        """
        return self._credential_type

LoginCredential._set_binding_type(type.StructType(
    'com.vmware.nsx.model.login_credential', {
        'credential_type': type.StringType(),
    },
    LoginCredential,
    False,
    None))



class MACAddressElement(VapiStruct):
    """
    MAC Address

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            'mac_address': 'mac_address',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 mac_address=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  mac_address: :class:`str` or ``None``
        :param mac_address: A MAC address. Must be 6 pairs of hexadecimal digits, upper or
            lower case, separated by colons or dashes. Examples:
            01:23:45:67:89:ab, 01-23-45-67-89-AB. format: mac-address
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.mac_address = mac_address
        VapiStruct.__init__(self)


MACAddressElement._set_binding_type(type.StructType(
    'com.vmware.nsx.model.MAC_address_element', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        'mac_address': type.OptionalType(type.StringType()),
    },
    MACAddressElement,
    False,
    None))



class MACAddressElementListResult(VapiStruct):
    """
    Collection of MAC address elements

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`MACAddressElement` or ``None``
        :param results: MAC address element list
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


MACAddressElementListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.MAC_address_element_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'MACAddressElement'))),
    },
    MACAddressElementListResult,
    False,
    None))



class MACSet(VapiStruct):
    """
    MACSet is used to group individual MAC addresses. MACSets can be used as
    sources and destinations in layer2 firewall rules. These can also be used
    as members of NSGroups.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'mac_addresses': 'mac_addresses',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 mac_addresses=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  mac_addresses: :class:`list` of :class:`str` or ``None``
        :param mac_addresses: MAC addresses format: mac-address
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.mac_addresses = mac_addresses
        VapiStruct.__init__(self)


MACSet._set_binding_type(type.StructType(
    'com.vmware.nsx.model.MAC_set', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'mac_addresses': type.OptionalType(type.ListType(type.StringType())),
    },
    MACSet,
    False,
    None))



class MACSetListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`MACSet` or ``None``
        :param results: Paged collection of MACSets
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


MACSetListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.MAC_set_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'MACSet'))),
    },
    MACSetListResult,
    False,
    None))



class MPAConfigProperties(VapiStruct):
    """
    Information about the management plane this node is communciating with

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'RmqBrokerCluster': 'rmq_broker_cluster',
                            'SharedSecret': 'shared_secret',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 rmq_broker_cluster=None,
                 shared_secret=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  rmq_broker_cluster: :class:`list` of :class:`BrokerProperties` or ``None``
        :param rmq_broker_cluster: The list of messaging brokers this controller is configured with.
        :type  shared_secret: :class:`str` or ``None``
        :param shared_secret: The shared secret to use when autnenticating to the management
            plane's message bus. Not returned in REST responses.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.rmq_broker_cluster = rmq_broker_cluster
        self.shared_secret = shared_secret
        VapiStruct.__init__(self)


MPAConfigProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.MPA_config_properties', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'RmqBrokerCluster': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'BrokerProperties'))),
        'SharedSecret': type.OptionalType(type.StringType()),
    },
    MPAConfigProperties,
    False,
    None))



class MacAddressCsvListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'file_name': 'file_name',
                            'last_update_timestamp': 'last_update_timestamp',
                            'results': 'results',
                            }

    def __init__(self,
                 file_name=None,
                 last_update_timestamp=None,
                 results=None,
                ):
        """
        :type  file_name: :class:`str` or ``None``
        :param file_name: File name set by HTTP server if API returns CSV result as a file.
        :type  last_update_timestamp: :class:`long` or ``None``
        :param last_update_timestamp: Timestamp when the data was last updated; unset if data source has
            never updated the data. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`MacTableCsvRecord` or ``None``
        :param results: 
        """
        self.file_name = file_name
        self.last_update_timestamp = last_update_timestamp
        self.results = results
        VapiStruct.__init__(self)


MacAddressCsvListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.mac_address_csv_list_result', {
        'file_name': type.OptionalType(type.StringType()),
        'last_update_timestamp': type.OptionalType(type.IntegerType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'MacTableCsvRecord'))),
    },
    MacAddressCsvListResult,
    False,
    None))



class MacAddressListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'last_update_timestamp': 'last_update_timestamp',
                            'logical_switch_id': 'logical_switch_id',
                            'results': 'results',
                            'transport_node_id': 'transport_node_id',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 last_update_timestamp=None,
                 logical_switch_id=None,
                 results=None,
                 transport_node_id=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_update_timestamp: :class:`long` or ``None``
        :param last_update_timestamp: Timestamp when the data was last updated; unset if data source has
            never updated the data. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  logical_switch_id: :class:`str` or ``None``
        :param logical_switch_id: The id of the logical Switch
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`MacTableEntry` or ``None``
        :param results: 
        :type  transport_node_id: :class:`str` or ``None``
        :param transport_node_id: Transport node identifier
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.last_update_timestamp = last_update_timestamp
        self.logical_switch_id = logical_switch_id
        self.results = results
        self.transport_node_id = transport_node_id
        VapiStruct.__init__(self)


MacAddressListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.mac_address_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'last_update_timestamp': type.OptionalType(type.IntegerType()),
        'logical_switch_id': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'MacTableEntry'))),
        'transport_node_id': type.OptionalType(type.StringType()),
    },
    MacAddressListResult,
    False,
    None))



class MacLearningCounters(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'mac_not_learned_packets_allowed': 'mac_not_learned_packets_allowed',
                            'mac_not_learned_packets_dropped': 'mac_not_learned_packets_dropped',
                            'macs_learned': 'macs_learned',
                            }

    def __init__(self,
                 mac_not_learned_packets_allowed=None,
                 mac_not_learned_packets_dropped=None,
                 macs_learned=None,
                ):
        """
        :type  mac_not_learned_packets_allowed: :class:`long` or ``None``
        :param mac_not_learned_packets_allowed: The number of packets with unknown source MAC address that are
            dispatched without learning the source MAC address. Applicable only
            when the MAC limit is reached and MAC Limit policy is
            MAC_LEARNING_LIMIT_POLICY_ALLOW. format: int64
        :type  mac_not_learned_packets_dropped: :class:`long` or ``None``
        :param mac_not_learned_packets_dropped: The number of packets with unknown source MAC address that are
            dropped without learning the source MAC address. Applicable only
            when the MAC limit is reached and MAC Limit policy is
            MAC_LEARNING_LIMIT_POLICY_DROP. format: int64
        :type  macs_learned: :class:`long` or ``None``
        :param macs_learned: Number of MACs learned format: int64
        """
        self.mac_not_learned_packets_allowed = mac_not_learned_packets_allowed
        self.mac_not_learned_packets_dropped = mac_not_learned_packets_dropped
        self.macs_learned = macs_learned
        VapiStruct.__init__(self)


MacLearningCounters._set_binding_type(type.StructType(
    'com.vmware.nsx.model.mac_learning_counters', {
        'mac_not_learned_packets_allowed': type.OptionalType(type.IntegerType()),
        'mac_not_learned_packets_dropped': type.OptionalType(type.IntegerType()),
        'macs_learned': type.OptionalType(type.IntegerType()),
    },
    MacLearningCounters,
    False,
    None))



class MacLearningSpec(VapiStruct):
    """
    MAC learning configuration

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    LIMIT_POLICY_ALLOW = "ALLOW"
    """


    """
    LIMIT_POLICY_DROP = "DROP"
    """


    """



    _canonical_to_pep_names = {
                            'aging_time': 'aging_time',
                            'enabled': 'enabled',
                            'limit': 'limit',
                            'limit_policy': 'limit_policy',
                            'remote_overlay_mac_limit': 'remote_overlay_mac_limit',
                            'unicast_flooding_allowed': 'unicast_flooding_allowed',
                            }

    def __init__(self,
                 aging_time=None,
                 enabled=None,
                 limit=None,
                 limit_policy=None,
                 remote_overlay_mac_limit=None,
                 unicast_flooding_allowed=None,
                ):
        """
        :type  aging_time: :class:`long` or ``None``
        :param aging_time: Aging time in sec for learned MAC address format: int32
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  enabled: :class:`bool` or ``None``
        :param enabled: Allowing source MAC address learning
        :type  limit: :class:`long` or ``None``
        :param limit: This property specifies the limit on the maximum number of MAC
            addresses that can be learned on a port. It is consumed by vswitch
            kernel module on the hypervisor while learning MACs per port for
            VMs that are local to the host. format: int32
        :type  limit_policy: :class:`str` or ``None``
        :param limit_policy: Possible values are: 
            
            * :attr:`MacLearningSpec.LIMIT_POLICY_ALLOW`
            * :attr:`MacLearningSpec.LIMIT_POLICY_DROP`
            
             The policy after MAC Limit is exceeded
        :type  remote_overlay_mac_limit: :class:`long` or ``None``
        :param remote_overlay_mac_limit: This property specifies the limit on the maximum number of MACs
            learned for a remote Virtual Machine's MAC to vtep binding per
            overlay logical switch. format: int32
        :type  unicast_flooding_allowed: :class:`bool` or ``None``
        :param unicast_flooding_allowed: Allowing flooding for unlearned MAC for ingress traffic
        """
        self.aging_time = aging_time
        self.enabled = enabled
        self.limit = limit
        self.limit_policy = limit_policy
        self.remote_overlay_mac_limit = remote_overlay_mac_limit
        self.unicast_flooding_allowed = unicast_flooding_allowed
        VapiStruct.__init__(self)


MacLearningSpec._set_binding_type(type.StructType(
    'com.vmware.nsx.model.mac_learning_spec', {
        'aging_time': type.OptionalType(type.IntegerType()),
        'enabled': type.OptionalType(type.BooleanType()),
        'limit': type.OptionalType(type.IntegerType()),
        'limit_policy': type.OptionalType(type.StringType()),
        'remote_overlay_mac_limit': type.OptionalType(type.IntegerType()),
        'unicast_flooding_allowed': type.OptionalType(type.BooleanType()),
    },
    MacLearningSpec,
    False,
    None))



class MacManagementSwitchingProfile(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "MacManagementSwitchingProfile"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'mac_change_allowed': 'mac_change_allowed',
                            'mac_learning': 'mac_learning',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'required_capabilities': 'required_capabilities',
                            }

    def __init__(self,
                 mac_change_allowed=None,
                 mac_learning=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='MacManagementSwitchingProfile',
                 tags=None,
                 required_capabilities=None,
                ):
        """
        :type  mac_change_allowed: :class:`bool` or ``None``
        :param mac_change_allowed: Allowing source MAC address change
        :type  mac_learning: :class:`MacLearningSpec` or ``None``
        :param mac_learning: MAC learning configuration
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: 
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  required_capabilities: :class:`list` of :class:`str` or ``None``
        :param required_capabilities: 
        """
        self.mac_change_allowed = mac_change_allowed
        self.mac_learning = mac_learning
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        self.required_capabilities = required_capabilities
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

MacManagementSwitchingProfile._set_binding_type(type.StructType(
    'com.vmware.nsx.model.mac_management_switching_profile', {
        'mac_change_allowed': type.OptionalType(type.BooleanType()),
        'mac_learning': type.OptionalType(type.ReferenceType(__name__, 'MacLearningSpec')),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'required_capabilities': type.OptionalType(type.ListType(type.StringType())),
    },
    MacManagementSwitchingProfile,
    False,
    None))



class MacPool(VapiStruct):
    """
    A collection of ranges of MAC addresses

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'ranges': 'ranges',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 ranges=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  ranges: :class:`list` of :class:`MacRange` or ``None``
        :param ranges: Array of ranges for MAC addresses
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.ranges = ranges
        VapiStruct.__init__(self)


MacPool._set_binding_type(type.StructType(
    'com.vmware.nsx.model.mac_pool', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'ranges': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'MacRange'))),
    },
    MacPool,
    False,
    None))



class MacPoolListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`MacPool` or ``None``
        :param results: MAC pool list results
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


MacPoolListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.mac_pool_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'MacPool'))),
    },
    MacPoolListResult,
    False,
    None))



class MacRange(VapiStruct):
    """
    A range of MAC addresses with a start and end value

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'end': 'end',
                            'start': 'start',
                            }

    def __init__(self,
                 end=None,
                 start=None,
                ):
        """
        :type  end: :class:`str` or ``None``
        :param end: End value for MAC address range format: mac-address
        :type  start: :class:`str` or ``None``
        :param start: Start value for MAC address range format: mac-address
        """
        self.end = end
        self.start = start
        VapiStruct.__init__(self)


MacRange._set_binding_type(type.StructType(
    'com.vmware.nsx.model.mac_range', {
        'end': type.OptionalType(type.StringType()),
        'start': type.OptionalType(type.StringType()),
    },
    MacRange,
    False,
    None))



class MacTableCsvRecord(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'mac_address': 'mac_address',
                            'rtep_group_id': 'rtep_group_id',
                            'vtep_group_id': 'vtep_group_id',
                            'vtep_ip': 'vtep_ip',
                            'vtep_mac_address': 'vtep_mac_address',
                            }

    def __init__(self,
                 mac_address=None,
                 rtep_group_id=None,
                 vtep_group_id=None,
                 vtep_ip=None,
                 vtep_mac_address=None,
                ):
        """
        :type  mac_address: :class:`str` or ``None``
        :param mac_address: The MAC address
        :type  rtep_group_id: :class:`long` or ``None``
        :param rtep_group_id: RTEP group id is applicable when the logical switch is stretched
            across multiple sites. When rtep_group_id is set, mac_address
            represents remote mac_address. format: int64
        :type  vtep_group_id: :class:`long` or ``None``
        :param vtep_group_id: VTEP group id is applicable when the logical switch is stretched
            across multiple sites. When vtep_group_id is set, mac_address
            represents remote mac_address. format: int64
        :type  vtep_ip: :class:`str` or ``None``
        :param vtep_ip: The virtual tunnel endpoint IP address format: ip
        :type  vtep_mac_address: :class:`str` or ``None``
        :param vtep_mac_address: The virtual tunnel endpoint MAC address
        """
        self.mac_address = mac_address
        self.rtep_group_id = rtep_group_id
        self.vtep_group_id = vtep_group_id
        self.vtep_ip = vtep_ip
        self.vtep_mac_address = vtep_mac_address
        VapiStruct.__init__(self)


MacTableCsvRecord._set_binding_type(type.StructType(
    'com.vmware.nsx.model.mac_table_csv_record', {
        'mac_address': type.OptionalType(type.StringType()),
        'rtep_group_id': type.OptionalType(type.IntegerType()),
        'vtep_group_id': type.OptionalType(type.IntegerType()),
        'vtep_ip': type.OptionalType(type.StringType()),
        'vtep_mac_address': type.OptionalType(type.StringType()),
    },
    MacTableCsvRecord,
    False,
    None))



class MacTableEntry(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'mac_address': 'mac_address',
                            'rtep_group_id': 'rtep_group_id',
                            'vtep_group_id': 'vtep_group_id',
                            'vtep_ip': 'vtep_ip',
                            'vtep_mac_address': 'vtep_mac_address',
                            }

    def __init__(self,
                 mac_address=None,
                 rtep_group_id=None,
                 vtep_group_id=None,
                 vtep_ip=None,
                 vtep_mac_address=None,
                ):
        """
        :type  mac_address: :class:`str` or ``None``
        :param mac_address: The MAC address
        :type  rtep_group_id: :class:`long` or ``None``
        :param rtep_group_id: RTEP group id is applicable when the logical switch is stretched
            across multiple sites. When rtep_group_id is set, mac_address
            represents remote mac_address. format: int64
        :type  vtep_group_id: :class:`long` or ``None``
        :param vtep_group_id: VTEP group id is applicable when the logical switch is stretched
            across multiple sites. When vtep_group_id is set, mac_address
            represents remote mac_address. format: int64
        :type  vtep_ip: :class:`str` or ``None``
        :param vtep_ip: The virtual tunnel endpoint IP address format: ip
        :type  vtep_mac_address: :class:`str` or ``None``
        :param vtep_mac_address: The virtual tunnel endpoint MAC address
        """
        self.mac_address = mac_address
        self.rtep_group_id = rtep_group_id
        self.vtep_group_id = vtep_group_id
        self.vtep_ip = vtep_ip
        self.vtep_mac_address = vtep_mac_address
        VapiStruct.__init__(self)


MacTableEntry._set_binding_type(type.StructType(
    'com.vmware.nsx.model.mac_table_entry', {
        'mac_address': type.OptionalType(type.StringType()),
        'rtep_group_id': type.OptionalType(type.IntegerType()),
        'vtep_group_id': type.OptionalType(type.IntegerType()),
        'vtep_ip': type.OptionalType(type.StringType()),
        'vtep_mac_address': type.OptionalType(type.StringType()),
    },
    MacTableEntry,
    False,
    None))



class ManagedResource(VapiStruct):
    """
    Base type for resources that are managed by API clients

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        VapiStruct.__init__(self)


ManagedResource._set_binding_type(type.StructType(
    'com.vmware.nsx.model.managed_resource', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
    },
    ManagedResource,
    False,
    None))



class ManagementClusterNodeStatus(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    MGMT_CLUSTER_STATUS_CONNECTED = "CONNECTED"
    """


    """
    MGMT_CLUSTER_STATUS_DISCONNECTED = "DISCONNECTED"
    """


    """
    MGMT_CLUSTER_STATUS_UNKNOWN = "UNKNOWN"
    """


    """



    _canonical_to_pep_names = {
                            'mgmt_cluster_status': 'mgmt_cluster_status',
                            }

    def __init__(self,
                 mgmt_cluster_status=None,
                ):
        """
        :type  mgmt_cluster_status: :class:`str` or ``None``
        :param mgmt_cluster_status: Possible values are: 
            
            * :attr:`ManagementClusterNodeStatus.MGMT_CLUSTER_STATUS_CONNECTED`
            *
              :attr:`ManagementClusterNodeStatus.MGMT_CLUSTER_STATUS_DISCONNECTED`
            * :attr:`ManagementClusterNodeStatus.MGMT_CLUSTER_STATUS_UNKNOWN`
            
             Status of this node's connection to the management cluster
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.mgmt_cluster_status = mgmt_cluster_status
        VapiStruct.__init__(self)


ManagementClusterNodeStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.management_cluster_node_status', {
        'mgmt_cluster_status': type.OptionalType(type.StringType()),
    },
    ManagementClusterNodeStatus,
    False,
    None))



class ManagementClusterRoleConfig(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    TYPE_MANAGEMENTCLUSTERROLECONFIG = "ManagementClusterRoleConfig"
    """


    """
    TYPE_CONTROLLERCLUSTERROLECONFIG = "ControllerClusterRoleConfig"
    """


    """



    _canonical_to_pep_names = {
                            'type': 'type',
                            'api_listen_addr': 'api_listen_addr',
                            'appliance_connection_info': 'appliance_connection_info',
                            'mgmt_cluster_listen_addr': 'mgmt_cluster_listen_addr',
                            'mgmt_plane_listen_addr': 'mgmt_plane_listen_addr',
                            'mpa_msg_client_info': 'mpa_msg_client_info',
                            }

    def __init__(self,
                 type=None,
                 api_listen_addr=None,
                 appliance_connection_info=None,
                 mgmt_cluster_listen_addr=None,
                 mgmt_plane_listen_addr=None,
                 mpa_msg_client_info=None,
                ):
        """
        :type  type: :class:`str` or ``None``
        :param type: Possible values are: 
            
            *
              :attr:`ManagementClusterRoleConfig.TYPE_MANAGEMENTCLUSTERROLECONFIG`
            *
              :attr:`ManagementClusterRoleConfig.TYPE_CONTROLLERCLUSTERROLECONFIG`
            
             Type of this role configuration
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  api_listen_addr: :class:`ServiceEndpoint` or ``None``
        :param api_listen_addr: The IP and port for the public API service on this node
        :type  appliance_connection_info: :class:`ServiceEndpoint` or ``None``
        :param appliance_connection_info: The IP, port and certificate for connecting to appliance.
        :type  mgmt_cluster_listen_addr: :class:`ServiceEndpoint` or ``None``
        :param mgmt_cluster_listen_addr: The IP and port for the management cluster service on this node
        :type  mgmt_plane_listen_addr: :class:`ServiceEndpoint` or ``None``
        :param mgmt_plane_listen_addr: The IP and port for the management plane service on this node
        :type  mpa_msg_client_info: :class:`MsgClientInfo` or ``None``
        :param mpa_msg_client_info: 
        """
        self.type = type
        self.api_listen_addr = api_listen_addr
        self.appliance_connection_info = appliance_connection_info
        self.mgmt_cluster_listen_addr = mgmt_cluster_listen_addr
        self.mgmt_plane_listen_addr = mgmt_plane_listen_addr
        self.mpa_msg_client_info = mpa_msg_client_info
        VapiStruct.__init__(self)


ManagementClusterRoleConfig._set_binding_type(type.StructType(
    'com.vmware.nsx.model.management_cluster_role_config', {
        'type': type.OptionalType(type.StringType()),
        'api_listen_addr': type.OptionalType(type.ReferenceType(__name__, 'ServiceEndpoint')),
        'appliance_connection_info': type.OptionalType(type.ReferenceType(__name__, 'ServiceEndpoint')),
        'mgmt_cluster_listen_addr': type.OptionalType(type.ReferenceType(__name__, 'ServiceEndpoint')),
        'mgmt_plane_listen_addr': type.OptionalType(type.ReferenceType(__name__, 'ServiceEndpoint')),
        'mpa_msg_client_info': type.OptionalType(type.ReferenceType(__name__, 'MsgClientInfo')),
    },
    ManagementClusterRoleConfig,
    False,
    None))



class ManagementClusterStatus(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATUS_INITIALIZING = "INITIALIZING"
    """


    """
    STATUS_UNSTABLE = "UNSTABLE"
    """


    """
    STATUS_DEGRADED = "DEGRADED"
    """


    """
    STATUS_STABLE = "STABLE"
    """


    """
    STATUS_UNKNOWN = "UNKNOWN"
    """


    """



    _canonical_to_pep_names = {
                            'offline_nodes': 'offline_nodes',
                            'online_nodes': 'online_nodes',
                            'required_members_for_initialization': 'required_members_for_initialization',
                            'status': 'status',
                            }

    def __init__(self,
                 offline_nodes=None,
                 online_nodes=None,
                 required_members_for_initialization=None,
                 status=None,
                ):
        """
        :type  offline_nodes: :class:`list` of :class:`ManagementPlaneBaseNodeInfo` or ``None``
        :param offline_nodes: Current missing management plane nodes
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  online_nodes: :class:`list` of :class:`ManagementPlaneBaseNodeInfo` or ``None``
        :param online_nodes: Current alive management plane nodes
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  required_members_for_initialization: :class:`list` of :class:`ClusterInitializationNodeInfo` or ``None``
        :param required_members_for_initialization: The details of the cluster nodes required for cluster
            initialization
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  status: :class:`str` or ``None``
        :param status: Possible values are: 
            
            * :attr:`ManagementClusterStatus.STATUS_INITIALIZING`
            * :attr:`ManagementClusterStatus.STATUS_UNSTABLE`
            * :attr:`ManagementClusterStatus.STATUS_DEGRADED`
            * :attr:`ManagementClusterStatus.STATUS_STABLE`
            * :attr:`ManagementClusterStatus.STATUS_UNKNOWN`
            
             The current status of the management cluster
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.offline_nodes = offline_nodes
        self.online_nodes = online_nodes
        self.required_members_for_initialization = required_members_for_initialization
        self.status = status
        VapiStruct.__init__(self)


ManagementClusterStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.management_cluster_status', {
        'offline_nodes': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ManagementPlaneBaseNodeInfo'))),
        'online_nodes': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ManagementPlaneBaseNodeInfo'))),
        'required_members_for_initialization': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ClusterInitializationNodeInfo'))),
        'status': type.OptionalType(type.StringType()),
    },
    ManagementClusterStatus,
    False,
    None))



class ManagementConfig(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            'publish_fqdns': 'publish_fqdns',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 publish_fqdns=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  publish_fqdns: :class:`bool` or ``None``
        :param publish_fqdns: True if Management nodes publish their fqdns(instead of default IP
            addresses) across NSX for its reachability.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.publish_fqdns = publish_fqdns
        VapiStruct.__init__(self)


ManagementConfig._set_binding_type(type.StructType(
    'com.vmware.nsx.model.management_config', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        'publish_fqdns': type.OptionalType(type.BooleanType()),
    },
    ManagementConfig,
    False,
    None))



class ManagementNodeAggregateInfo(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'display_name': 'display_name',
                            'id': 'id',
                            'node_interface_properties': 'node_interface_properties',
                            'node_interface_statistics': 'node_interface_statistics',
                            'node_status': 'node_status',
                            'node_status_properties': 'node_status_properties',
                            'role_config': 'role_config',
                            'transport_nodes_connected': 'transport_nodes_connected',
                            }

    def __init__(self,
                 display_name=None,
                 id=None,
                 node_interface_properties=None,
                 node_interface_statistics=None,
                 node_status=None,
                 node_status_properties=None,
                 role_config=None,
                 transport_nodes_connected=None,
                ):
        """
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  node_interface_properties: :class:`list` of :class:`NodeInterfaceProperties` or ``None``
        :param node_interface_properties: Array of Node interface statistic properties
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  node_interface_statistics: :class:`list` of :class:`NodeInterfaceStatisticsProperties` or ``None``
        :param node_interface_statistics: Array of Node network interface statistic properties
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  node_status: :class:`ClusterNodeStatus` or ``None``
        :param node_status: 
        :type  node_status_properties: :class:`list` of :class:`NodeStatusProperties` or ``None``
        :param node_status_properties: Time series of the node's system properties
        :type  role_config: :class:`ManagementClusterRoleConfig` or ``None``
        :param role_config: 
        :type  transport_nodes_connected: :class:`long` or ``None``
        :param transport_nodes_connected: 
        """
        self.display_name = display_name
        self.id = id
        self.node_interface_properties = node_interface_properties
        self.node_interface_statistics = node_interface_statistics
        self.node_status = node_status
        self.node_status_properties = node_status_properties
        self.role_config = role_config
        self.transport_nodes_connected = transport_nodes_connected
        VapiStruct.__init__(self)


ManagementNodeAggregateInfo._set_binding_type(type.StructType(
    'com.vmware.nsx.model.management_node_aggregate_info', {
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'node_interface_properties': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NodeInterfaceProperties'))),
        'node_interface_statistics': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NodeInterfaceStatisticsProperties'))),
        'node_status': type.OptionalType(type.ReferenceType(__name__, 'ClusterNodeStatus')),
        'node_status_properties': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NodeStatusProperties'))),
        'role_config': type.OptionalType(type.ReferenceType(__name__, 'ManagementClusterRoleConfig')),
        'transport_nodes_connected': type.OptionalType(type.IntegerType()),
    },
    ManagementNodeAggregateInfo,
    False,
    None))



class ManagementPlaneBaseNodeInfo(VapiStruct):
    """
    The basic node info of management plane node

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'mgmt_cluster_listen_ip_address': 'mgmt_cluster_listen_ip_address',
                            'uuid': 'uuid',
                            }

    def __init__(self,
                 mgmt_cluster_listen_ip_address=None,
                 uuid=None,
                ):
        """
        :type  mgmt_cluster_listen_ip_address: :class:`str` or ``None``
        :param mgmt_cluster_listen_ip_address: The IP address of MP node
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  uuid: :class:`str` or ``None``
        :param uuid: Management plane node UUID
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.mgmt_cluster_listen_ip_address = mgmt_cluster_listen_ip_address
        self.uuid = uuid
        VapiStruct.__init__(self)


ManagementPlaneBaseNodeInfo._set_binding_type(type.StructType(
    'com.vmware.nsx.model.management_plane_base_node_info', {
        'mgmt_cluster_listen_ip_address': type.OptionalType(type.StringType()),
        'uuid': type.OptionalType(type.StringType()),
    },
    ManagementPlaneBaseNodeInfo,
    False,
    None))



class ManagementPlaneBrokerProperties(VapiStruct):
    """
    Information about a management plane node this controller is configured to
    communicate with

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'host': 'host',
                            'port': 'port',
                            'thumbprint': 'thumbprint',
                            }

    def __init__(self,
                 host=None,
                 port=None,
                 thumbprint=None,
                ):
        """
        :type  host: :class:`str` or ``None``
        :param host: IP address or hostname of the message bus broker on the management
            plane node. format: hostname-or-ipv4
        :type  port: :class:`long` or ``None``
        :param port: Port number of the message bus broker on the management plane node.
            format: int64
        :type  thumbprint: :class:`str` or ``None``
        :param thumbprint: Certificate thumbprint of the message bus broker on the management
            plane node.
        """
        self.host = host
        self.port = port
        self.thumbprint = thumbprint
        VapiStruct.__init__(self)


ManagementPlaneBrokerProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.management_plane_broker_properties', {
        'host': type.OptionalType(type.StringType()),
        'port': type.OptionalType(type.IntegerType()),
        'thumbprint': type.OptionalType(type.StringType()),
    },
    ManagementPlaneBrokerProperties,
    False,
    None))



class ManagementPlaneProperties(VapiStruct):
    """
    Information about the management plane this controller is communciating
    with

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'brokers': 'brokers',
                            'secret': 'secret',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 brokers=None,
                 secret=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  brokers: :class:`list` of :class:`ManagementPlaneBrokerProperties` or ``None``
        :param brokers: The list of messaging brokers this controller is configured with.
        :type  secret: :class:`str` or ``None``
        :param secret: The shared secret to use when autnenticating to the management
            plane's message bus. Not returned in REST responses.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.brokers = brokers
        self.secret = secret
        VapiStruct.__init__(self)


ManagementPlaneProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.management_plane_properties', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'brokers': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ManagementPlaneBrokerProperties'))),
        'secret': type.OptionalType(type.StringType()),
    },
    ManagementPlaneProperties,
    False,
    None))



class MandatoryAccessControlProperties(VapiStruct):
    """
    Information about mandatory access control

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATUS_ENABLED = "ENABLED"
    """


    """
    STATUS_DISABLED = "DISABLED"
    """


    """
    STATUS_ENABLED_PENDING_REBOOT = "ENABLED_PENDING_REBOOT"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'enabled': 'enabled',
                            'status': 'status',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 enabled=None,
                 status=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  enabled: :class:`bool` or ``None``
        :param enabled: Enabled can be True/False
        :type  status: :class:`str` or ``None``
        :param status: Possible values are: 
            
            * :attr:`MandatoryAccessControlProperties.STATUS_ENABLED`
            * :attr:`MandatoryAccessControlProperties.STATUS_DISABLED`
            *
              :attr:`MandatoryAccessControlProperties.STATUS_ENABLED_PENDING_REBOOT`
            
             current status of Mandatory Access Control
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.enabled = enabled
        self.status = status
        VapiStruct.__init__(self)


MandatoryAccessControlProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.mandatory_access_control_properties', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'enabled': type.OptionalType(type.BooleanType()),
        'status': type.OptionalType(type.StringType()),
    },
    MandatoryAccessControlProperties,
    False,
    None))



class ManualHealthCheck(VapiStruct):
    """
    Describes a manual check to evaluate the status of a transport zone.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    OPERATION_STATUS_IN_PROGRESS = "IN_PROGRESS"
    """


    """
    OPERATION_STATUS_FINISHED = "FINISHED"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'operation_status': 'operation_status',
                            'result': 'result',
                            'transport_zone_id': 'transport_zone_id',
                            'vlans': 'vlans',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 operation_status=None,
                 result=None,
                 transport_zone_id=None,
                 vlans=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  operation_status: :class:`str` or ``None``
        :param operation_status: Possible values are: 
            
            * :attr:`ManualHealthCheck.OPERATION_STATUS_IN_PROGRESS`
            * :attr:`ManualHealthCheck.OPERATION_STATUS_FINISHED`
            
             The operation status for health check
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result: :class:`HealthCheckResult` or ``None``
        :param result: 
        :type  transport_zone_id: :class:`str` or ``None``
        :param transport_zone_id: The entity ID works as a filter param. Entity ID and entity type
            should be both provided or not at a query.
        :type  vlans: :class:`HealthCheckSpecVlans` or ``None``
        :param vlans: VLANs specificied for manual health check
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.operation_status = operation_status
        self.result = result
        self.transport_zone_id = transport_zone_id
        self.vlans = vlans
        VapiStruct.__init__(self)


ManualHealthCheck._set_binding_type(type.StructType(
    'com.vmware.nsx.model.manual_health_check', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'operation_status': type.OptionalType(type.StringType()),
        'result': type.OptionalType(type.ReferenceType(__name__, 'HealthCheckResult')),
        'transport_zone_id': type.OptionalType(type.StringType()),
        'vlans': type.OptionalType(type.ReferenceType(__name__, 'HealthCheckSpecVlans')),
    },
    ManualHealthCheck,
    False,
    None))



class ManualHealthCheckListResult(VapiStruct):
    """
    Manual health check list result for query with list parameters.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`ManualHealthCheck` or ``None``
        :param results: Manual Health Check List
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


ManualHealthCheckListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.manual_health_check_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ManualHealthCheck'))),
    },
    ManualHealthCheckListResult,
    False,
    None))



class MemoryReservation(VapiStruct):
    """
    Relative to the form factor pre-defined reservation value. To reduce
    reservation of a VM to 50 percent, a user may specify 50 instead of the
    absolute number relevant for the edge form factor.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'reservation_percentage': 'reservation_percentage',
                            }

    def __init__(self,
                 reservation_percentage=None,
                ):
        """
        :type  reservation_percentage: :class:`long` or ``None``
        :param reservation_percentage: Memory reserved relative to the default reservation of 100 percent.
            For example, take an edge virtual machine of medium form factor. By
            default, an edge of medium form factor is configured with 8 GB of
            memory and with reservation of 100 percent. So, 8 GB of memory is
            reserved. If you specify reservation_percentage value as 50
            percent, then 4 GB of memory will be reserved. format: int32
        """
        self.reservation_percentage = reservation_percentage
        VapiStruct.__init__(self)


MemoryReservation._set_binding_type(type.StructType(
    'com.vmware.nsx.model.memory_reservation', {
        'reservation_percentage': type.OptionalType(type.IntegerType()),
    },
    MemoryReservation,
    False,
    None))



class MessagingClientInfo(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    CLIENT_TYPE_MPA = "MPA"
    """


    """
    CLIENT_TYPE_HOST = "HOST"
    """


    """



    _canonical_to_pep_names = {
                            'account_name': 'account_name',
                            'client_type': 'client_type',
                            }

    def __init__(self,
                 account_name=None,
                 client_type=None,
                ):
        """
        :type  account_name: :class:`str` or ``None``
        :param account_name: Account name in messaging client
        :type  client_type: :class:`str` or ``None``
        :param client_type: Possible values are: 
            
            * :attr:`MessagingClientInfo.CLIENT_TYPE_MPA`
            * :attr:`MessagingClientInfo.CLIENT_TYPE_HOST`
            
             Type of messaging client
        """
        self.account_name = account_name
        self.client_type = client_type
        VapiStruct.__init__(self)


MessagingClientInfo._set_binding_type(type.StructType(
    'com.vmware.nsx.model.messaging_client_info', {
        'account_name': type.OptionalType(type.StringType()),
        'client_type': type.OptionalType(type.StringType()),
    },
    MessagingClientInfo,
    False,
    None))



class MetadataProxy(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    CRYPTO_PROTOCOLS_V1 = "TLS_V1"
    """


    """
    CRYPTO_PROTOCOLS_V1_1 = "TLS_V1_1"
    """


    """
    CRYPTO_PROTOCOLS_V1_2 = "TLS_V1_2"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'attached_logical_port_id': 'attached_logical_port_id',
                            'crypto_protocols': 'crypto_protocols',
                            'edge_cluster_id': 'edge_cluster_id',
                            'edge_cluster_member_indexes': 'edge_cluster_member_indexes',
                            'enable_standby_relocation': 'enable_standby_relocation',
                            'metadata_server_ca_ids': 'metadata_server_ca_ids',
                            'metadata_server_url': 'metadata_server_url',
                            'secret': 'secret',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 attached_logical_port_id=None,
                 crypto_protocols=None,
                 edge_cluster_id=None,
                 edge_cluster_member_indexes=None,
                 enable_standby_relocation=None,
                 metadata_server_ca_ids=None,
                 metadata_server_url=None,
                 secret=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  attached_logical_port_id: :class:`str` or ``None``
        :param attached_logical_port_id: id of attached logical port
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  crypto_protocols: :class:`list` of :class:`str` or ``None``
        :param crypto_protocols: Possible values are: 
            
            * :attr:`MetadataProxy.CRYPTO_PROTOCOLS_V1`
            * :attr:`MetadataProxy.CRYPTO_PROTOCOLS_V1_1`
            * :attr:`MetadataProxy.CRYPTO_PROTOCOLS_V1_2`
            
            The cryptographic protocols listed here are supported by the
            metadata proxy. The TLSv1.1 and TLSv1.2 are supported by default.
        :type  edge_cluster_id: :class:`str` or ``None``
        :param edge_cluster_id: edge cluster uuid
        :type  edge_cluster_member_indexes: :class:`list` of :class:`long` or ``None``
        :param edge_cluster_member_indexes: If none is provided, the NSX will auto-select two edge-nodes from
            the given edge cluster. If user provides only one edge node, there
            will be no HA support. format: int64
        :type  enable_standby_relocation: :class:`bool` or ``None``
        :param enable_standby_relocation: Flag to enable the auto-relocation of standby Metadata Proxy in
            case of edge node failure. Only tier 1 and auto placed Metadata
            Proxy are considered for the relocation.
        :type  metadata_server_ca_ids: :class:`list` of :class:`str` or ``None``
        :param metadata_server_ca_ids: The CAs referenced here must be uploaded to the truststore using
            the API POST /api/v1/trust-management/certificates?action=import.
            User needs to ensure a correct CA for this metedata server is used.
            The REST API can not detect a wrong CA which was used to verify a
            different server. If the Metadata Proxy reports an ERROR or
            NO_BACKUP status, user can check the metadata proxy log at
            transport node for a possible CA issue.
        :type  metadata_server_url: :class:`str` or ``None``
        :param metadata_server_url: The URL in format scheme://host:port/path. Please note, the scheme
            supports only http and https as of now, port supports range 3000 -
            9000, inclusive.
        :type  secret: :class:`str` or ``None``
        :param secret: secret to access metadata server
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.attached_logical_port_id = attached_logical_port_id
        self.crypto_protocols = crypto_protocols
        self.edge_cluster_id = edge_cluster_id
        self.edge_cluster_member_indexes = edge_cluster_member_indexes
        self.enable_standby_relocation = enable_standby_relocation
        self.metadata_server_ca_ids = metadata_server_ca_ids
        self.metadata_server_url = metadata_server_url
        self.secret = secret
        VapiStruct.__init__(self)


MetadataProxy._set_binding_type(type.StructType(
    'com.vmware.nsx.model.metadata_proxy', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'attached_logical_port_id': type.OptionalType(type.StringType()),
        'crypto_protocols': type.OptionalType(type.ListType(type.StringType())),
        'edge_cluster_id': type.OptionalType(type.StringType()),
        'edge_cluster_member_indexes': type.OptionalType(type.ListType(type.IntegerType())),
        'enable_standby_relocation': type.OptionalType(type.BooleanType()),
        'metadata_server_ca_ids': type.OptionalType(type.ListType(type.StringType())),
        'metadata_server_url': type.OptionalType(type.StringType()),
        'secret': type.OptionalType(type.StringType()),
    },
    MetadataProxy,
    False,
    None))



class MetadataProxyListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`MetadataProxy` or ``None``
        :param results: paginated list of metadata proxies
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


MetadataProxyListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.metadata_proxy_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'MetadataProxy'))),
    },
    MetadataProxyListResult,
    False,
    None))



class MetadataProxyStatistics(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'metadata_proxy_id': 'metadata_proxy_id',
                            'statistics': 'statistics',
                            'timestamp': 'timestamp',
                            }

    def __init__(self,
                 metadata_proxy_id=None,
                 statistics=None,
                 timestamp=None,
                ):
        """
        :type  metadata_proxy_id: :class:`str` or ``None``
        :param metadata_proxy_id: metadata proxy uuid
        :type  statistics: :class:`list` of :class:`MetadataProxyStatisticsPerLogicalSwitch` or ``None``
        :param statistics: metadata proxy statistics per logical switch
        :type  timestamp: :class:`long` or ``None``
        :param timestamp: timestamp of the statistics format: int64
        """
        self.metadata_proxy_id = metadata_proxy_id
        self.statistics = statistics
        self.timestamp = timestamp
        VapiStruct.__init__(self)


MetadataProxyStatistics._set_binding_type(type.StructType(
    'com.vmware.nsx.model.metadata_proxy_statistics', {
        'metadata_proxy_id': type.OptionalType(type.StringType()),
        'statistics': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'MetadataProxyStatisticsPerLogicalSwitch'))),
        'timestamp': type.OptionalType(type.IntegerType()),
    },
    MetadataProxyStatistics,
    False,
    None))



class MetadataProxyStatisticsPerLogicalSwitch(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'error_responses_from_nova_server': 'error_responses_from_nova_server',
                            'logical_switch_id': 'logical_switch_id',
                            'requests_from_clients': 'requests_from_clients',
                            'requests_to_nova_server': 'requests_to_nova_server',
                            'responses_to_clients': 'responses_to_clients',
                            'succeeded_responses_from_nova_server': 'succeeded_responses_from_nova_server',
                            }

    def __init__(self,
                 error_responses_from_nova_server=None,
                 logical_switch_id=None,
                 requests_from_clients=None,
                 requests_to_nova_server=None,
                 responses_to_clients=None,
                 succeeded_responses_from_nova_server=None,
                ):
        """
        :type  error_responses_from_nova_server: :class:`long` or ``None``
        :param error_responses_from_nova_server: error responses from nova server format: int64
        :type  logical_switch_id: :class:`str` or ``None``
        :param logical_switch_id: uuid of attached logical switch
        :type  requests_from_clients: :class:`long` or ``None``
        :param requests_from_clients: requests from clients format: int64
        :type  requests_to_nova_server: :class:`long` or ``None``
        :param requests_to_nova_server: requests to nova server format: int64
        :type  responses_to_clients: :class:`long` or ``None``
        :param responses_to_clients: responses to clients format: int64
        :type  succeeded_responses_from_nova_server: :class:`long` or ``None``
        :param succeeded_responses_from_nova_server: succeeded responses from nova server format: int64
        """
        self.error_responses_from_nova_server = error_responses_from_nova_server
        self.logical_switch_id = logical_switch_id
        self.requests_from_clients = requests_from_clients
        self.requests_to_nova_server = requests_to_nova_server
        self.responses_to_clients = responses_to_clients
        self.succeeded_responses_from_nova_server = succeeded_responses_from_nova_server
        VapiStruct.__init__(self)


MetadataProxyStatisticsPerLogicalSwitch._set_binding_type(type.StructType(
    'com.vmware.nsx.model.metadata_proxy_statistics_per_logical_switch', {
        'error_responses_from_nova_server': type.OptionalType(type.IntegerType()),
        'logical_switch_id': type.OptionalType(type.StringType()),
        'requests_from_clients': type.OptionalType(type.IntegerType()),
        'requests_to_nova_server': type.OptionalType(type.IntegerType()),
        'responses_to_clients': type.OptionalType(type.IntegerType()),
        'succeeded_responses_from_nova_server': type.OptionalType(type.IntegerType()),
    },
    MetadataProxyStatisticsPerLogicalSwitch,
    False,
    None))



class MetadataProxyStatus(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    PROXY_STATUS_UP = "UP"
    """


    """
    PROXY_STATUS_DOWN = "DOWN"
    """


    """
    PROXY_STATUS_ERROR = "ERROR"
    """


    """
    PROXY_STATUS_NO_BACKUP = "NO_BACKUP"
    """


    """



    _canonical_to_pep_names = {
                            'error_message': 'error_message',
                            'proxy_status': 'proxy_status',
                            'transport_nodes': 'transport_nodes',
                            }

    def __init__(self,
                 error_message=None,
                 proxy_status=None,
                 transport_nodes=None,
                ):
        """
        :type  error_message: :class:`str` or ``None``
        :param error_message: Error message, if available
        :type  proxy_status: :class:`str` or ``None``
        :param proxy_status: Possible values are: 
            
            * :attr:`MetadataProxyStatus.PROXY_STATUS_UP`
            * :attr:`MetadataProxyStatus.PROXY_STATUS_DOWN`
            * :attr:`MetadataProxyStatus.PROXY_STATUS_ERROR`
            * :attr:`MetadataProxyStatus.PROXY_STATUS_NO_BACKUP`
            
            UP means the metadata proxy is working fine on both
            transport-nodes(if have); DOWN means the metadata proxy is is down
            on both transport-nodes(if have), hence the metadata proxy will not
            repsonse any metadata request; Error means error happens on
            transport-node(s) or no status is reported from transport-node(s).
            The metadata proxy may be working (or not working); NO_BACK means
            metadata proxy is working in one of the transport node while not in
            the other transport-node (if have). Hence if the metadata proxy in
            the working transport-node goes down, the metadata proxy will go
            down.
        :type  transport_nodes: :class:`list` of :class:`str` or ``None``
        :param transport_nodes: Order of the transport nodes is insensitive because Metadata Proxy
            is running in Active-Active mode among target transport nodes.
        """
        self.error_message = error_message
        self.proxy_status = proxy_status
        self.transport_nodes = transport_nodes
        VapiStruct.__init__(self)


MetadataProxyStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.metadata_proxy_status', {
        'error_message': type.OptionalType(type.StringType()),
        'proxy_status': type.OptionalType(type.StringType()),
        'transport_nodes': type.OptionalType(type.ListType(type.StringType())),
    },
    MetadataProxyStatus,
    False,
    None))



class MgmtConnStatus(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    CONNECTIVITY_STATUS_CONNECTED = "CONNECTED"
    """


    """
    CONNECTIVITY_STATUS_DISCONNECTED = "DISCONNECTED"
    """


    """
    CONNECTIVITY_STATUS_UNKNOWN = "UNKNOWN"
    """


    """



    _canonical_to_pep_names = {
                            'connectivity_status': 'connectivity_status',
                            }

    def __init__(self,
                 connectivity_status=None,
                ):
        """
        :type  connectivity_status: :class:`str` or ``None``
        :param connectivity_status: Possible values are: 
            
            * :attr:`MgmtConnStatus.CONNECTIVITY_STATUS_CONNECTED`
            * :attr:`MgmtConnStatus.CONNECTIVITY_STATUS_DISCONNECTED`
            * :attr:`MgmtConnStatus.CONNECTIVITY_STATUS_UNKNOWN`
            
             Indicates the controller node's MP channel connectivity status
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.connectivity_status = connectivity_status
        VapiStruct.__init__(self)


MgmtConnStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.mgmt_conn_status', {
        'connectivity_status': type.OptionalType(type.StringType()),
    },
    MgmtConnStatus,
    False,
    None))



class MigrationFeedbackCategory(VapiStruct):
    """
    Categorization of feedback requests from the migration tool where user
    input is required.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'accepted_values': 'accepted_values',
                            'category': 'category',
                            'count': 'count',
                            'resolved': 'resolved',
                            }

    def __init__(self,
                 accepted_values=None,
                 category=None,
                 count=None,
                 resolved=None,
                ):
        """
        :type  accepted_values: :class:`list` of :class:`str` or ``None``
        :param accepted_values: List of acceptable values for this feedback request.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  category: :class:`str` or ``None``
        :param category: Functional area that this query falls into.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  count: :class:`long` or ``None``
        :param count: Total number of feedback requests for this functional area. format:
            int32
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  resolved: :class:`long` or ``None``
        :param resolved: Total number of resolved feedback requests for this functional
            area. format: int32
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.accepted_values = accepted_values
        self.category = category
        self.count = count
        self.resolved = resolved
        VapiStruct.__init__(self)


MigrationFeedbackCategory._set_binding_type(type.StructType(
    'com.vmware.nsx.model.migration_feedback_category', {
        'accepted_values': type.OptionalType(type.ListType(type.StringType())),
        'category': type.OptionalType(type.StringType()),
        'count': type.OptionalType(type.IntegerType()),
        'resolved': type.OptionalType(type.IntegerType()),
    },
    MigrationFeedbackCategory,
    False,
    None))



class MigrationFeedbackRequest(VapiStruct):
    """
    Detailed feedback requests from the migration tool where user input is
    required.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'accepted_actions': 'accepted_actions',
                            'accepted_value_type': 'accepted_value_type',
                            'accepted_values': 'accepted_values',
                            'hash': 'hash',
                            'id': 'id',
                            'message': 'message',
                            'multi_value': 'multi_value',
                            'object_id': 'object_id',
                            'rejected': 'rejected',
                            'resolution': 'resolution',
                            'resolved': 'resolved',
                            'sub_vertical': 'sub_vertical',
                            'suggested_action': 'suggested_action',
                            'suggested_value': 'suggested_value',
                            'v_object_id': 'v_object_id',
                            'v_object_name': 'v_object_name',
                            'vertical': 'vertical',
                            }

    def __init__(self,
                 accepted_actions=None,
                 accepted_value_type=None,
                 accepted_values=None,
                 hash=None,
                 id=None,
                 message=None,
                 multi_value=None,
                 object_id=None,
                 rejected=None,
                 resolution=None,
                 resolved=None,
                 sub_vertical=None,
                 suggested_action=None,
                 suggested_value=None,
                 v_object_id=None,
                 v_object_name=None,
                 vertical=None,
                ):
        """
        :type  accepted_actions: :class:`list` of :class:`str` or ``None``
        :param accepted_actions: List of acceptable actions for this feedback request.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  accepted_value_type: :class:`str` or ``None``
        :param accepted_value_type: Data type of the items listed in acceptable values list.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  accepted_values: :class:`list` of :class:`str` or ``None``
        :param accepted_values: List of acceptable values for this feedback request.
        :type  hash: :class:`str` or ``None``
        :param hash: Identify a feedback request type across objects. This can be used
            to group together objects with similar feedback request and resolve
            them in one go.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  id: :class:`str` or ``None``
        :param id: Identifier of the feedback request.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  message: :class:`str` or ``None``
        :param message: Detailed feedback request with options.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  multi_value: :class:`bool` or ``None``
        :param multi_value: Indicates if multiple values can be selected as response from the
            list of acceptable value.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  object_id: :class:`str` or ``None``
        :param object_id: Identifier of the object for which feedback is requested.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  rejected: :class:`bool` or ``None``
        :param rejected: Indicates if previous response was invalid. Please provide a valid
            response.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  resolution: :class:`str` or ``None``
        :param resolution: If the feedback request was resolved earlier, provides details
            about the previous resolution.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  resolved: :class:`bool` or ``None``
        :param resolved: Indicates if a valid response already exist for this feedback
            request.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sub_vertical: :class:`str` or ``None``
        :param sub_vertical: Functional sub-area that this query falls into.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  suggested_action: :class:`str` or ``None``
        :param suggested_action: The suggested action to resolve this feedback request.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  suggested_value: :class:`str` or ``None``
        :param suggested_value: The suggested value to resolve this feedback request.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  v_object_id: :class:`str` or ``None``
        :param v_object_id: Identifier for this object in the source NSX endpoint.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  v_object_name: :class:`str` or ``None``
        :param v_object_name: Name of this object in the source NSX endpoint.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  vertical: :class:`str` or ``None``
        :param vertical: Functional area that this query falls into.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.accepted_actions = accepted_actions
        self.accepted_value_type = accepted_value_type
        self.accepted_values = accepted_values
        self.hash = hash
        self.id = id
        self.message = message
        self.multi_value = multi_value
        self.object_id = object_id
        self.rejected = rejected
        self.resolution = resolution
        self.resolved = resolved
        self.sub_vertical = sub_vertical
        self.suggested_action = suggested_action
        self.suggested_value = suggested_value
        self.v_object_id = v_object_id
        self.v_object_name = v_object_name
        self.vertical = vertical
        VapiStruct.__init__(self)


MigrationFeedbackRequest._set_binding_type(type.StructType(
    'com.vmware.nsx.model.migration_feedback_request', {
        'accepted_actions': type.OptionalType(type.ListType(type.StringType())),
        'accepted_value_type': type.OptionalType(type.StringType()),
        'accepted_values': type.OptionalType(type.ListType(type.StringType())),
        'hash': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'message': type.OptionalType(type.StringType()),
        'multi_value': type.OptionalType(type.BooleanType()),
        'object_id': type.OptionalType(type.StringType()),
        'rejected': type.OptionalType(type.BooleanType()),
        'resolution': type.OptionalType(type.StringType()),
        'resolved': type.OptionalType(type.BooleanType()),
        'sub_vertical': type.OptionalType(type.StringType()),
        'suggested_action': type.OptionalType(type.StringType()),
        'suggested_value': type.OptionalType(type.StringType()),
        'v_object_id': type.OptionalType(type.StringType()),
        'v_object_name': type.OptionalType(type.StringType()),
        'vertical': type.OptionalType(type.StringType()),
    },
    MigrationFeedbackRequest,
    False,
    None))



class MigrationFeedbackRequestListResult(VapiStruct):
    """
    List of detailed feedback requests from the migration tool where user input
    is required.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`MigrationFeedbackRequest` or ``None``
        :param results: Paged Collection of feedback requests
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


MigrationFeedbackRequestListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.migration_feedback_request_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'MigrationFeedbackRequest'))),
    },
    MigrationFeedbackRequestListResult,
    False,
    None))



class MigrationFeedbackResponse(VapiStruct):
    """
    Detailed feedback requests from the migration tool where user input is
    required.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'action': 'action',
                            'id': 'id',
                            'value': 'value',
                            'values': 'values',
                            }

    def __init__(self,
                 action=None,
                 id=None,
                 value=None,
                 values=None,
                ):
        """
        :type  action: :class:`str` or ``None``
        :param action: Action selected in response to the feedback request.
        :type  id: :class:`str` or ``None``
        :param id: Identifier of the feedback request.
        :type  value: :class:`str` or ``None``
        :param value: User input provided in response to the feedback request.
        :type  values: :class:`list` of :class:`str` or ``None``
        :param values: User input provided in the form of a list of values in response to
            the feedback request.
        """
        self.action = action
        self.id = id
        self.value = value
        self.values = values
        VapiStruct.__init__(self)


MigrationFeedbackResponse._set_binding_type(type.StructType(
    'com.vmware.nsx.model.migration_feedback_response', {
        'action': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'value': type.OptionalType(type.StringType()),
        'values': type.OptionalType(type.ListType(type.StringType())),
    },
    MigrationFeedbackResponse,
    False,
    None))



class MigrationFeedbackResponseList(VapiStruct):
    """
    List of detailed feedback response for the migration tool.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'response_list': 'response_list',
                            }

    def __init__(self,
                 response_list=None,
                ):
        """
        :type  response_list: :class:`list` of :class:`MigrationFeedbackResponse` or ``None``
        :param response_list: List of feedback responses.
        """
        self.response_list = response_list
        VapiStruct.__init__(self)


MigrationFeedbackResponseList._set_binding_type(type.StructType(
    'com.vmware.nsx.model.migration_feedback_response_list', {
        'response_list': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'MigrationFeedbackResponse'))),
    },
    MigrationFeedbackResponseList,
    False,
    None))



class MigrationFeedbackSummaryListResult(VapiStruct):
    """
    List of feedback categories and count of requests in each category.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`MigrationFeedbackCategory` or ``None``
        :param results: Paged Collection of feedback categories
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


MigrationFeedbackSummaryListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.migration_feedback_summary_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'MigrationFeedbackCategory'))),
    },
    MigrationFeedbackSummaryListResult,
    False,
    None))



class MigrationPlanSettings(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'parallel': 'parallel',
                            'pause_after_each_group': 'pause_after_each_group',
                            'pause_on_error': 'pause_on_error',
                            }

    def __init__(self,
                 parallel=None,
                 pause_after_each_group=None,
                 pause_on_error=None,
                ):
        """
        :type  parallel: :class:`bool` or ``None``
        :param parallel: Migration Method to specify whether the migration is to be
            performed serially or in parallel
        :type  pause_after_each_group: :class:`bool` or ``None``
        :param pause_after_each_group: Flag to indicate whether to pause the migration after migration of
            each group is completed
        :type  pause_on_error: :class:`bool` or ``None``
        :param pause_on_error: Flag to indicate whether to pause the migration plan execution when
            an error occurs
        """
        self.parallel = parallel
        self.pause_after_each_group = pause_after_each_group
        self.pause_on_error = pause_on_error
        VapiStruct.__init__(self)


MigrationPlanSettings._set_binding_type(type.StructType(
    'com.vmware.nsx.model.migration_plan_settings', {
        'parallel': type.OptionalType(type.BooleanType()),
        'pause_after_each_group': type.OptionalType(type.BooleanType()),
        'pause_on_error': type.OptionalType(type.BooleanType()),
    },
    MigrationPlanSettings,
    False,
    None))



class MigrationSetupInfo(VapiStruct):
    """
    Details about source and destination NSX setup to be migrated

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    MIGRATION_MODE_VMC_V2T = "VMC_V2T"
    """


    """
    MIGRATION_MODE_ONPREMISE_V2T = "ONPREMISE_V2T"
    """


    """
    MIGRATION_MODE_ONPREMISE_VSPHERE2T = "ONPREMISE_VSPHERE2T"
    """


    """



    _canonical_to_pep_names = {
                            'destination_nsx': 'destination_nsx',
                            'migration_mode': 'migration_mode',
                            'source_nsx': 'source_nsx',
                            }

    def __init__(self,
                 destination_nsx=None,
                 migration_mode=None,
                 source_nsx=None,
                ):
        """
        :type  destination_nsx: :class:`DestinationNsxApiEndpoint` or ``None``
        :param destination_nsx: IP address or hostname of the destination NSX API endpoint.
        :type  migration_mode: :class:`str` or ``None``
        :param migration_mode: Possible values are: 
            
            * :attr:`MigrationSetupInfo.MIGRATION_MODE_VMC_V2T`
            * :attr:`MigrationSetupInfo.MIGRATION_MODE_ONPREMISE_V2T`
            * :attr:`MigrationSetupInfo.MIGRATION_MODE_ONPREMISE_VSPHERE2T`
            
             Migration mode can be VMC_V2T, ONPREMISE_V2T, ONPREMISE_VSPHERE2T
        :type  source_nsx: :class:`list` of :class:`SourceNsxApiEndpoint` or ``None``
        :param source_nsx: List of source NSX manager endpoints.
        """
        self.destination_nsx = destination_nsx
        self.migration_mode = migration_mode
        self.source_nsx = source_nsx
        VapiStruct.__init__(self)


MigrationSetupInfo._set_binding_type(type.StructType(
    'com.vmware.nsx.model.migration_setup_info', {
        'destination_nsx': type.OptionalType(type.ReferenceType(__name__, 'DestinationNsxApiEndpoint')),
        'migration_mode': type.OptionalType(type.StringType()),
        'source_nsx': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'SourceNsxApiEndpoint'))),
    },
    MigrationSetupInfo,
    False,
    None))



class MigrationStatus(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    OVERALL_MIGRATION_STATUS_SUCCESS = "SUCCESS"
    """


    """
    OVERALL_MIGRATION_STATUS_FAILED = "FAILED"
    """


    """
    OVERALL_MIGRATION_STATUS_IN_PROGRESS = "IN_PROGRESS"
    """


    """
    OVERALL_MIGRATION_STATUS_NOT_STARTED = "NOT_STARTED"
    """


    """
    OVERALL_MIGRATION_STATUS_PAUSED = "PAUSED"
    """


    """



    _canonical_to_pep_names = {
                            'component_status': 'component_status',
                            'overall_migration_status': 'overall_migration_status',
                            }

    def __init__(self,
                 component_status=None,
                 overall_migration_status=None,
                ):
        """
        :type  component_status: :class:`list` of :class:`ComponentMigrationStatus` or ``None``
        :param component_status: List of component statuses
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  overall_migration_status: :class:`str` or ``None``
        :param overall_migration_status: Possible values are: 
            
            * :attr:`MigrationStatus.OVERALL_MIGRATION_STATUS_SUCCESS`
            * :attr:`MigrationStatus.OVERALL_MIGRATION_STATUS_FAILED`
            * :attr:`MigrationStatus.OVERALL_MIGRATION_STATUS_IN_PROGRESS`
            * :attr:`MigrationStatus.OVERALL_MIGRATION_STATUS_NOT_STARTED`
            * :attr:`MigrationStatus.OVERALL_MIGRATION_STATUS_PAUSED`
            
             Status of migration
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.component_status = component_status
        self.overall_migration_status = overall_migration_status
        VapiStruct.__init__(self)


MigrationStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.migration_status', {
        'component_status': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ComponentMigrationStatus'))),
        'overall_migration_status': type.OptionalType(type.StringType()),
    },
    MigrationStatus,
    False,
    None))



class MigrationSummary(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    MIGRATION_STATUS_SUCCESS = "SUCCESS"
    """


    """
    MIGRATION_STATUS_FAILED = "FAILED"
    """


    """
    MIGRATION_STATUS_IN_PROGRESS = "IN_PROGRESS"
    """


    """
    MIGRATION_STATUS_NOT_STARTED = "NOT_STARTED"
    """


    """
    MIGRATION_STATUS_PAUSED = "PAUSED"
    """


    """



    _canonical_to_pep_names = {
                            'component_target_versions': 'component_target_versions',
                            'migration_coordinator_version': 'migration_coordinator_version',
                            'migration_status': 'migration_status',
                            'system_version': 'system_version',
                            'target_version': 'target_version',
                            }

    def __init__(self,
                 component_target_versions=None,
                 migration_coordinator_version=None,
                 migration_status=None,
                 system_version=None,
                 target_version=None,
                ):
        """
        :type  component_target_versions: :class:`list` of :class:`ComponentTargetVersion` or ``None``
        :param component_target_versions: 
        :type  migration_coordinator_version: :class:`str` or ``None``
        :param migration_coordinator_version: Current version of migration coordinator
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  migration_status: :class:`str` or ``None``
        :param migration_status: Possible values are: 
            
            * :attr:`MigrationSummary.MIGRATION_STATUS_SUCCESS`
            * :attr:`MigrationSummary.MIGRATION_STATUS_FAILED`
            * :attr:`MigrationSummary.MIGRATION_STATUS_IN_PROGRESS`
            * :attr:`MigrationSummary.MIGRATION_STATUS_NOT_STARTED`
            * :attr:`MigrationSummary.MIGRATION_STATUS_PAUSED`
            
             Status of migration
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_version: :class:`str` or ``None``
        :param system_version: Current system version
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  target_version: :class:`str` or ``None``
        :param target_version: Target system version
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.component_target_versions = component_target_versions
        self.migration_coordinator_version = migration_coordinator_version
        self.migration_status = migration_status
        self.system_version = system_version
        self.target_version = target_version
        VapiStruct.__init__(self)


MigrationSummary._set_binding_type(type.StructType(
    'com.vmware.nsx.model.migration_summary', {
        'component_target_versions': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ComponentTargetVersion'))),
        'migration_coordinator_version': type.OptionalType(type.StringType()),
        'migration_status': type.OptionalType(type.StringType()),
        'system_version': type.OptionalType(type.StringType()),
        'target_version': type.OptionalType(type.StringType()),
    },
    MigrationSummary,
    False,
    None))



class MigrationSwitchInfo(VapiStruct):
    """
    Details about switch to be migrated

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    KIND_DVS = "DVS"
    """


    """
    KIND_VSS = "VSS"
    """


    """



    _canonical_to_pep_names = {
                            'id': 'id',
                            'kind': 'kind',
                            'name': 'name',
                            'pnic_count': 'pnic_count',
                            'version': 'version',
                            }

    def __init__(self,
                 id=None,
                 kind=None,
                 name=None,
                 pnic_count=None,
                 version=None,
                ):
        """
        :type  id: :class:`str` or ``None``
        :param id: Switch Identifier.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  kind: :class:`str` or ``None``
        :param kind: Possible values are: 
            
            * :attr:`MigrationSwitchInfo.KIND_DVS`
            * :attr:`MigrationSwitchInfo.KIND_VSS`
            
             Kind of switch, can be DVS, VSS.
        :type  name: :class:`str` or ``None``
        :param name: Name of the switch.
        :type  pnic_count: :class:`long` or ``None``
        :param pnic_count: Number of PNICs associated with this switch. format: int32
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  version: :class:`str` or ``None``
        :param version: Version of the switch to be migrated.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.id = id
        self.kind = kind
        self.name = name
        self.pnic_count = pnic_count
        self.version = version
        VapiStruct.__init__(self)


MigrationSwitchInfo._set_binding_type(type.StructType(
    'com.vmware.nsx.model.migration_switch_info', {
        'id': type.OptionalType(type.StringType()),
        'kind': type.OptionalType(type.StringType()),
        'name': type.OptionalType(type.StringType()),
        'pnic_count': type.OptionalType(type.IntegerType()),
        'version': type.OptionalType(type.StringType()),
    },
    MigrationSwitchInfo,
    False,
    None))



class MigrationSwitchListResult(VapiStruct):
    """
    Details about all the DVS and VSS present on the VC

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`MigrationSwitchInfo` or ``None``
        :param results: A paginated list of DVS/VSS present on the VC.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


MigrationSwitchListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.migration_switch_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'MigrationSwitchInfo'))),
    },
    MigrationSwitchListResult,
    False,
    None))



class MigrationUnit(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'current_version': 'current_version',
                            'display_name': 'display_name',
                            'group': 'group',
                            'id': 'id',
                            'metadata': 'metadata',
                            'type': 'type',
                            'warnings': 'warnings',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 current_version=None,
                 display_name=None,
                 group=None,
                 id=None,
                 metadata=None,
                 type=None,
                 warnings=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  current_version: :class:`str` or ``None``
        :param current_version: This is component version e.g. if migration unit is of type HOST,
            then this is host version.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  display_name: :class:`str` or ``None``
        :param display_name: Name of the migration unit
        :type  group: :class:`ResourceReference` or ``None``
        :param group: Info of the group to which this migration unit belongs
        :type  id: :class:`str` or ``None``
        :param id: Identifier of the migration unit
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  metadata: :class:`list` of :class:`KeyValuePair` or ``None``
        :param metadata: Metadata about migration unit
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  type: :class:`str` or ``None``
        :param type: Migration unit type
        :type  warnings: :class:`list` of :class:`str` or ``None``
        :param warnings: List of warnings indicating issues with the migration unit that may
            result in migration failure
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.current_version = current_version
        self.display_name = display_name
        self.group = group
        self.id = id
        self.metadata = metadata
        self.type = type
        self.warnings = warnings
        VapiStruct.__init__(self)


MigrationUnit._set_binding_type(type.StructType(
    'com.vmware.nsx.model.migration_unit', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'current_version': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'group': type.OptionalType(type.ReferenceType(__name__, 'ResourceReference')),
        'id': type.OptionalType(type.StringType()),
        'metadata': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'KeyValuePair'))),
        'type': type.OptionalType(type.StringType()),
        'warnings': type.OptionalType(type.ListType(type.StringType())),
    },
    MigrationUnit,
    False,
    None))



class MigrationUnitAggregateInfo(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATUS_SUCCESS = "SUCCESS"
    """


    """
    STATUS_FAILED = "FAILED"
    """


    """
    STATUS_IN_PROGRESS = "IN_PROGRESS"
    """


    """
    STATUS_NOT_STARTED = "NOT_STARTED"
    """


    """
    STATUS_PAUSED = "PAUSED"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'errors': 'errors',
                            'percent_complete': 'percent_complete',
                            'status': 'status',
                            'unit': 'unit',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 errors=None,
                 percent_complete=None,
                 status=None,
                 unit=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  errors: :class:`list` of :class:`str` or ``None``
        :param errors: List of errors occurred during migration of this migration unit
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  percent_complete: :class:`float` or ``None``
        :param percent_complete: Indicator of migration progress in percentage
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  status: :class:`str` or ``None``
        :param status: Possible values are: 
            
            * :attr:`MigrationUnitAggregateInfo.STATUS_SUCCESS`
            * :attr:`MigrationUnitAggregateInfo.STATUS_FAILED`
            * :attr:`MigrationUnitAggregateInfo.STATUS_IN_PROGRESS`
            * :attr:`MigrationUnitAggregateInfo.STATUS_NOT_STARTED`
            * :attr:`MigrationUnitAggregateInfo.STATUS_PAUSED`
            
             Status of migration unit
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  unit: :class:`MigrationUnit` or ``None``
        :param unit: Details of the migration unit
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.errors = errors
        self.percent_complete = percent_complete
        self.status = status
        self.unit = unit
        VapiStruct.__init__(self)


MigrationUnitAggregateInfo._set_binding_type(type.StructType(
    'com.vmware.nsx.model.migration_unit_aggregate_info', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'errors': type.OptionalType(type.ListType(type.StringType())),
        'percent_complete': type.OptionalType(type.DoubleType()),
        'status': type.OptionalType(type.StringType()),
        'unit': type.OptionalType(type.ReferenceType(__name__, 'MigrationUnit')),
    },
    MigrationUnitAggregateInfo,
    False,
    None))



class MigrationUnitAggregateInfoListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`MigrationUnitAggregateInfo` or ``None``
        :param results: Paged collection of MigrationUnit AggregateInfo
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


MigrationUnitAggregateInfoListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.migration_unit_aggregate_info_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'MigrationUnitAggregateInfo'))),
    },
    MigrationUnitAggregateInfoListResult,
    False,
    None))



class MigrationUnitGroup(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'enabled': 'enabled',
                            'extended_configuration': 'extended_configuration',
                            'migration_unit_count': 'migration_unit_count',
                            'migration_units': 'migration_units',
                            'parallel': 'parallel',
                            'type': 'type',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 enabled=None,
                 extended_configuration=None,
                 migration_unit_count=None,
                 migration_units=None,
                 parallel=None,
                 type=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  enabled: :class:`bool` or ``None``
        :param enabled: Flag to indicate whether migration of this group is enabled or not
        :type  extended_configuration: :class:`list` of :class:`KeyValuePair` or ``None``
        :param extended_configuration: Extended configuration for the group
        :type  migration_unit_count: :class:`long` or ``None``
        :param migration_unit_count: Number of migration units in the group format: int32
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  migration_units: :class:`list` of :class:`MigrationUnit` or ``None``
        :param migration_units: List of migration units in the group
        :type  parallel: :class:`bool` or ``None``
        :param parallel: Migration method to specify whether the migration is to be
            performed in parallel or serially
        :type  type: :class:`str` or ``None``
        :param type: Component type
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.enabled = enabled
        self.extended_configuration = extended_configuration
        self.migration_unit_count = migration_unit_count
        self.migration_units = migration_units
        self.parallel = parallel
        self.type = type
        VapiStruct.__init__(self)


MigrationUnitGroup._set_binding_type(type.StructType(
    'com.vmware.nsx.model.migration_unit_group', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'enabled': type.OptionalType(type.BooleanType()),
        'extended_configuration': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'KeyValuePair'))),
        'migration_unit_count': type.OptionalType(type.IntegerType()),
        'migration_units': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'MigrationUnit'))),
        'parallel': type.OptionalType(type.BooleanType()),
        'type': type.OptionalType(type.StringType()),
    },
    MigrationUnitGroup,
    False,
    None))



class MigrationUnitGroupAggregateInfo(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATUS_SUCCESS = "SUCCESS"
    """


    """
    STATUS_FAILED = "FAILED"
    """


    """
    STATUS_IN_PROGRESS = "IN_PROGRESS"
    """


    """
    STATUS_NOT_STARTED = "NOT_STARTED"
    """


    """
    STATUS_PAUSED = "PAUSED"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'failed_count': 'failed_count',
                            'group': 'group',
                            'percent_complete': 'percent_complete',
                            'status': 'status',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 failed_count=None,
                 group=None,
                 percent_complete=None,
                 status=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  failed_count: :class:`long` or ``None``
        :param failed_count: Number of nodes in the migration unit group that failed migration
            format: int32
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  group: :class:`MigrationUnitGroup` or ``None``
        :param group: Migration unit group details
        :type  percent_complete: :class:`float` or ``None``
        :param percent_complete: Indicator of migration progress in percentage
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  status: :class:`str` or ``None``
        :param status: Possible values are: 
            
            * :attr:`MigrationUnitGroupAggregateInfo.STATUS_SUCCESS`
            * :attr:`MigrationUnitGroupAggregateInfo.STATUS_FAILED`
            * :attr:`MigrationUnitGroupAggregateInfo.STATUS_IN_PROGRESS`
            * :attr:`MigrationUnitGroupAggregateInfo.STATUS_NOT_STARTED`
            * :attr:`MigrationUnitGroupAggregateInfo.STATUS_PAUSED`
            
             Migration status of migration unit group
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.failed_count = failed_count
        self.group = group
        self.percent_complete = percent_complete
        self.status = status
        VapiStruct.__init__(self)


MigrationUnitGroupAggregateInfo._set_binding_type(type.StructType(
    'com.vmware.nsx.model.migration_unit_group_aggregate_info', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'failed_count': type.OptionalType(type.IntegerType()),
        'group': type.OptionalType(type.ReferenceType(__name__, 'MigrationUnitGroup')),
        'percent_complete': type.OptionalType(type.DoubleType()),
        'status': type.OptionalType(type.StringType()),
    },
    MigrationUnitGroupAggregateInfo,
    False,
    None))



class MigrationUnitGroupAggregateInfoListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`MigrationUnitGroupAggregateInfo` or ``None``
        :param results: Paged collection of migration status for migration unit groups
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


MigrationUnitGroupAggregateInfoListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.migration_unit_group_aggregate_info_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'MigrationUnitGroupAggregateInfo'))),
    },
    MigrationUnitGroupAggregateInfoListResult,
    False,
    None))



class MigrationUnitGroupListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`MigrationUnitGroup` or ``None``
        :param results: Paged Collection of Migration unit groups
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


MigrationUnitGroupListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.migration_unit_group_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'MigrationUnitGroup'))),
    },
    MigrationUnitGroupListResult,
    False,
    None))



class MigrationUnitGroupStatus(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATUS_SUCCESS = "SUCCESS"
    """


    """
    STATUS_FAILED = "FAILED"
    """


    """
    STATUS_IN_PROGRESS = "IN_PROGRESS"
    """


    """
    STATUS_NOT_STARTED = "NOT_STARTED"
    """


    """
    STATUS_PAUSED = "PAUSED"
    """


    """



    _canonical_to_pep_names = {
                            'failed_count': 'failed_count',
                            'group_id': 'group_id',
                            'group_name': 'group_name',
                            'migration_unit_count': 'migration_unit_count',
                            'percent_complete': 'percent_complete',
                            'status': 'status',
                            }

    def __init__(self,
                 failed_count=None,
                 group_id=None,
                 group_name=None,
                 migration_unit_count=None,
                 percent_complete=None,
                 status=None,
                ):
        """
        :type  failed_count: :class:`long` or ``None``
        :param failed_count: Number of nodes in the migration unit group that failed migration
            format: int32
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  group_id: :class:`str` or ``None``
        :param group_id: Identifier for migration unit group
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  group_name: :class:`str` or ``None``
        :param group_name: Name of the migration unit group
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  migration_unit_count: :class:`long` or ``None``
        :param migration_unit_count: Number of migration units in the group format: int32
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  percent_complete: :class:`float` or ``None``
        :param percent_complete: Indicator of migration progress in percentage
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  status: :class:`str` or ``None``
        :param status: Possible values are: 
            
            * :attr:`MigrationUnitGroupStatus.STATUS_SUCCESS`
            * :attr:`MigrationUnitGroupStatus.STATUS_FAILED`
            * :attr:`MigrationUnitGroupStatus.STATUS_IN_PROGRESS`
            * :attr:`MigrationUnitGroupStatus.STATUS_NOT_STARTED`
            * :attr:`MigrationUnitGroupStatus.STATUS_PAUSED`
            
             Migration status of migration unit group
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.failed_count = failed_count
        self.group_id = group_id
        self.group_name = group_name
        self.migration_unit_count = migration_unit_count
        self.percent_complete = percent_complete
        self.status = status
        VapiStruct.__init__(self)


MigrationUnitGroupStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.migration_unit_group_status', {
        'failed_count': type.OptionalType(type.IntegerType()),
        'group_id': type.OptionalType(type.StringType()),
        'group_name': type.OptionalType(type.StringType()),
        'migration_unit_count': type.OptionalType(type.IntegerType()),
        'percent_complete': type.OptionalType(type.DoubleType()),
        'status': type.OptionalType(type.StringType()),
    },
    MigrationUnitGroupStatus,
    False,
    None))



class MigrationUnitGroupStatusListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`MigrationUnitGroupStatus` or ``None``
        :param results: Paged collection of migration status for migration unit groups
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


MigrationUnitGroupStatusListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.migration_unit_group_status_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'MigrationUnitGroupStatus'))),
    },
    MigrationUnitGroupStatusListResult,
    False,
    None))



class MigrationUnitList(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'list': 'list',
                            }

    def __init__(self,
                 list=None,
                ):
        """
        :type  list: :class:`list` of :class:`MigrationUnit` or ``None``
        :param list: Collection of Migration units
        """
        self.list = list
        VapiStruct.__init__(self)


MigrationUnitList._set_binding_type(type.StructType(
    'com.vmware.nsx.model.migration_unit_list', {
        'list': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'MigrationUnit'))),
    },
    MigrationUnitList,
    False,
    None))



class MigrationUnitListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`MigrationUnit` or ``None``
        :param results: Paged Collection of Migration units
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


MigrationUnitListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.migration_unit_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'MigrationUnit'))),
    },
    MigrationUnitListResult,
    False,
    None))



class MigrationUnitStatus(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATUS_SUCCESS = "SUCCESS"
    """


    """
    STATUS_FAILED = "FAILED"
    """


    """
    STATUS_IN_PROGRESS = "IN_PROGRESS"
    """


    """
    STATUS_NOT_STARTED = "NOT_STARTED"
    """


    """
    STATUS_PAUSED = "PAUSED"
    """


    """



    _canonical_to_pep_names = {
                            'display_name': 'display_name',
                            'errors': 'errors',
                            'id': 'id',
                            'percent_complete': 'percent_complete',
                            'status': 'status',
                            }

    def __init__(self,
                 display_name=None,
                 errors=None,
                 id=None,
                 percent_complete=None,
                 status=None,
                ):
        """
        :type  display_name: :class:`str` or ``None``
        :param display_name: Name of migration unit
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  errors: :class:`list` of :class:`str` or ``None``
        :param errors: List of errors occurred during migration of this migration unit
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  id: :class:`str` or ``None``
        :param id: Identifier of migration unit
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  percent_complete: :class:`float` or ``None``
        :param percent_complete: Indicator of migration progress in percentage
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  status: :class:`str` or ``None``
        :param status: Possible values are: 
            
            * :attr:`MigrationUnitStatus.STATUS_SUCCESS`
            * :attr:`MigrationUnitStatus.STATUS_FAILED`
            * :attr:`MigrationUnitStatus.STATUS_IN_PROGRESS`
            * :attr:`MigrationUnitStatus.STATUS_NOT_STARTED`
            * :attr:`MigrationUnitStatus.STATUS_PAUSED`
            
             Status of migration unit
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.display_name = display_name
        self.errors = errors
        self.id = id
        self.percent_complete = percent_complete
        self.status = status
        VapiStruct.__init__(self)


MigrationUnitStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.migration_unit_status', {
        'display_name': type.OptionalType(type.StringType()),
        'errors': type.OptionalType(type.ListType(type.StringType())),
        'id': type.OptionalType(type.StringType()),
        'percent_complete': type.OptionalType(type.DoubleType()),
        'status': type.OptionalType(type.StringType()),
    },
    MigrationUnitStatus,
    False,
    None))



class MigrationUnitStatusListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`MigrationUnitStatus` or ``None``
        :param results: Paged Collection of migration units status
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


MigrationUnitStatusListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.migration_unit_status_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'MigrationUnitStatus'))),
    },
    MigrationUnitStatusListResult,
    False,
    None))



class MigrationUnitTypeStats(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'node_count': 'node_count',
                            'node_with_issues_count': 'node_with_issues_count',
                            'type': 'type',
                            'version': 'version',
                            }

    def __init__(self,
                 node_count=None,
                 node_with_issues_count=None,
                 type=None,
                 version=None,
                ):
        """
        :type  node_count: :class:`long` or ``None``
        :param node_count: Number of nodes format: int32
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  node_with_issues_count: :class:`long` or ``None``
        :param node_with_issues_count: Number of nodes with issues that may cause migration failure
            format: int32
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  type: :class:`str` or ``None``
        :param type: Type of migration unit
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  version: :class:`str` or ``None``
        :param version: Version of the migration unit
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.node_count = node_count
        self.node_with_issues_count = node_with_issues_count
        self.type = type
        self.version = version
        VapiStruct.__init__(self)


MigrationUnitTypeStats._set_binding_type(type.StructType(
    'com.vmware.nsx.model.migration_unit_type_stats', {
        'node_count': type.OptionalType(type.IntegerType()),
        'node_with_issues_count': type.OptionalType(type.IntegerType()),
        'type': type.OptionalType(type.StringType()),
        'version': type.OptionalType(type.StringType()),
    },
    MigrationUnitTypeStats,
    False,
    None))



class MigrationUnitTypeStatsList(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`MigrationUnitTypeStats` or ``None``
        :param results: List of migration unit type stats
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


MigrationUnitTypeStatsList._set_binding_type(type.StructType(
    'com.vmware.nsx.model.migration_unit_type_stats_list', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'MigrationUnitTypeStats'))),
    },
    MigrationUnitTypeStatsList,
    False,
    None))



class MirrorDestination(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "MirrorDestination"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    RESOURCE_TYPE_LOGICALPORTMIRRORDESTINATION = "LogicalPortMirrorDestination"
    """


    """
    RESOURCE_TYPE_PNICMIRRORDESTINATION = "PnicMirrorDestination"
    """


    """
    RESOURCE_TYPE_IPMIRRORDESTINATION = "IPMirrorDestination"
    """


    """



    _canonical_to_pep_names = {
                            'resource_type': 'resource_type',
                            }

    def __init__(self,
                 resource_type='MirrorDestination',
                ):
        """
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            *
              :attr:`MirrorDestination.RESOURCE_TYPE_LOGICALPORTMIRRORDESTINATION`
            * :attr:`MirrorDestination.RESOURCE_TYPE_PNICMIRRORDESTINATION`
            * :attr:`MirrorDestination.RESOURCE_TYPE_IPMIRRORDESTINATION`
            
             Resource types of mirror destination
        """
        self._resource_type = resource_type
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

MirrorDestination._set_binding_type(type.StructType(
    'com.vmware.nsx.model.mirror_destination', {
        'resource_type': type.StringType(),
    },
    MirrorDestination,
    False,
    None))



class MirrorSource(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "MirrorSource"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    RESOURCE_TYPE_LOGICALPORTMIRRORSOURCE = "LogicalPortMirrorSource"
    """


    """
    RESOURCE_TYPE_PNICMIRRORSOURCE = "PnicMirrorSource"
    """


    """
    RESOURCE_TYPE_VLANMIRRORSOURCE = "VlanMirrorSource"
    """


    """
    RESOURCE_TYPE_LOGICALSWITCHMIRRORSOURCE = "LogicalSwitchMirrorSource"
    """


    """



    _canonical_to_pep_names = {
                            'resource_type': 'resource_type',
                            }

    def __init__(self,
                 resource_type='MirrorSource',
                ):
        """
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`MirrorSource.RESOURCE_TYPE_LOGICALPORTMIRRORSOURCE`
            * :attr:`MirrorSource.RESOURCE_TYPE_PNICMIRRORSOURCE`
            * :attr:`MirrorSource.RESOURCE_TYPE_VLANMIRRORSOURCE`
            * :attr:`MirrorSource.RESOURCE_TYPE_LOGICALSWITCHMIRRORSOURCE`
            
             Resource types of mirror source
        """
        self._resource_type = resource_type
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

MirrorSource._set_binding_type(type.StructType(
    'com.vmware.nsx.model.mirror_source', {
        'resource_type': type.StringType(),
    },
    MirrorSource,
    False,
    None))



class MonitoringEvent(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    NODE_TYPES_AUTONOMOUS_EDGE = "nsx_autonomous_edge"
    """


    """
    NODE_TYPES_BMS = "nsx_bms"
    """


    """
    NODE_TYPES_EDGE = "nsx_edge"
    """


    """
    NODE_TYPES_ESX = "nsx_esx"
    """


    """
    NODE_TYPES_GLOBAL_MANAGER = "nsx_global_manager"
    """


    """
    NODE_TYPES_INTELLIGENCE = "nsx_intelligence"
    """


    """
    NODE_TYPES_KVM = "nsx_kvm"
    """


    """
    NODE_TYPES_MANAGER = "nsx_manager"
    """


    """
    NODE_TYPES_PUBLIC_CLOUD_GATEWAY = "nsx_public_cloud_gateway"
    """


    """
    SEVERITY_CRITICAL = "CRITICAL"
    """


    """
    SEVERITY_HIGH = "HIGH"
    """


    """
    SEVERITY_MEDIUM = "MEDIUM"
    """


    """
    SEVERITY_LOW = "LOW"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'description_on_clear': 'description_on_clear',
                            'entity_resource_type': 'entity_resource_type',
                            'event_false_snmp_oid': 'event_false_snmp_oid',
                            'event_true_snmp_oid': 'event_true_snmp_oid',
                            'event_type': 'event_type',
                            'event_type_display_name': 'event_type_display_name',
                            'feature_display_name': 'feature_display_name',
                            'feature_name': 'feature_name',
                            'is_disabled': 'is_disabled',
                            'is_threshold_fixed': 'is_threshold_fixed',
                            'node_types': 'node_types',
                            'recommended_action': 'recommended_action',
                            'sensitivity': 'sensitivity',
                            'severity': 'severity',
                            'summary': 'summary',
                            'suppress_alarm': 'suppress_alarm',
                            'suppress_snmp_trap': 'suppress_snmp_trap',
                            'threshold': 'threshold',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 description_on_clear=None,
                 entity_resource_type=None,
                 event_false_snmp_oid=None,
                 event_true_snmp_oid=None,
                 event_type=None,
                 event_type_display_name=None,
                 feature_display_name=None,
                 feature_name=None,
                 is_disabled=None,
                 is_threshold_fixed=None,
                 node_types=None,
                 recommended_action=None,
                 sensitivity=None,
                 severity=None,
                 summary=None,
                 suppress_alarm=None,
                 suppress_snmp_trap=None,
                 threshold=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Detailed description of the event.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier in the form of feature_name.event_type.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  description_on_clear: :class:`str` or ``None``
        :param description_on_clear: Description of Event when an Event instance transitions from True
            to False.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  entity_resource_type: :class:`str` or ``None``
        :param entity_resource_type: Resource Type of entity where this event is applicable eg.
            LogicalSwitch, LogicalPort etc.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  event_false_snmp_oid: :class:`str` or ``None``
        :param event_false_snmp_oid: Optional field containing OID for SNMP trap sent when Event
            instance is False. This value is null if suppress_snmp_trap or
            suppress_clear_oid is True.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  event_true_snmp_oid: :class:`str` or ``None``
        :param event_true_snmp_oid: Optional field containing OID for SNMP trap sent when Event
            instance is True. This value is null if suppress_snmp_trap is True.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  event_type: :class:`str` or ``None``
        :param event_type: Name of Event, e.g. manager_cpu_usage_high, certificate_expired.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  event_type_display_name: :class:`str` or ``None``
        :param event_type_display_name: Display name of Event type.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  feature_display_name: :class:`str` or ``None``
        :param feature_display_name: Display name of feature defining this Event.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  feature_name: :class:`str` or ``None``
        :param feature_name: Feature defining this Event, e.g. manager_health, certificates.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  is_disabled: :class:`bool` or ``None``
        :param is_disabled: Flag to indicate whether sampling for this Event is off or on.
        :type  is_threshold_fixed: :class:`bool` or ``None``
        :param is_threshold_fixed: Indicates if the threshold property is configurable via the API.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  node_types: :class:`list` of :class:`str` or ``None``
        :param node_types: Possible values are: 
            
            * :attr:`MonitoringEvent.NODE_TYPES_AUTONOMOUS_EDGE`
            * :attr:`MonitoringEvent.NODE_TYPES_BMS`
            * :attr:`MonitoringEvent.NODE_TYPES_EDGE`
            * :attr:`MonitoringEvent.NODE_TYPES_ESX`
            * :attr:`MonitoringEvent.NODE_TYPES_GLOBAL_MANAGER`
            * :attr:`MonitoringEvent.NODE_TYPES_INTELLIGENCE`
            * :attr:`MonitoringEvent.NODE_TYPES_KVM`
            * :attr:`MonitoringEvent.NODE_TYPES_MANAGER`
            * :attr:`MonitoringEvent.NODE_TYPES_PUBLIC_CLOUD_GATEWAY`
            
            Array identifying the nodes on which this Event is applicable. Can
            be one or more of the following values - nsx_public_cloud_gateway,
            nsx_edge, nsx_esx, nsx_kvm, nsx_manager.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  recommended_action: :class:`str` or ``None``
        :param recommended_action: Recommended action for the alarm condition.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sensitivity: :class:`long` or ``None``
        :param sensitivity: Percentage of samples to consider and used in combination with
            threshold when determining whether an Event instance status is True
            or False. Event evaluation uses sampling to determine Event
            instance status. A higher sensitivity value specifies that more
            samples are used to ensure accuracy and ignore infrequent or rare
            spikes in sampled data. format: int64
        :type  severity: :class:`str` or ``None``
        :param severity: Possible values are: 
            
            * :attr:`MonitoringEvent.SEVERITY_CRITICAL`
            * :attr:`MonitoringEvent.SEVERITY_HIGH`
            * :attr:`MonitoringEvent.SEVERITY_MEDIUM`
            * :attr:`MonitoringEvent.SEVERITY_LOW`
            
             Severity of the Event.Can be one of - CRITICAL, HIGH, MEDIUM, LOW.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  summary: :class:`str` or ``None``
        :param summary: Summary description of the event.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  suppress_alarm: :class:`bool` or ``None``
        :param suppress_alarm: Flag to suppress Alarm generation. Alarms are not generated for
            this Event when this is set to True.
        :type  suppress_snmp_trap: :class:`bool` or ``None``
        :param suppress_snmp_trap: Flag to suppress SNMP trap generation. SNMP traps are not sent for
            this Event when this is set to True.
        :type  threshold: :class:`long` or ``None``
        :param threshold: Threshold to determine if a single sample is True. For example, if
            the configured threshold is 95% and the current CPU sample is 99%,
            then the current sample is considered True. format: int64
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.description_on_clear = description_on_clear
        self.entity_resource_type = entity_resource_type
        self.event_false_snmp_oid = event_false_snmp_oid
        self.event_true_snmp_oid = event_true_snmp_oid
        self.event_type = event_type
        self.event_type_display_name = event_type_display_name
        self.feature_display_name = feature_display_name
        self.feature_name = feature_name
        self.is_disabled = is_disabled
        self.is_threshold_fixed = is_threshold_fixed
        self.node_types = node_types
        self.recommended_action = recommended_action
        self.sensitivity = sensitivity
        self.severity = severity
        self.summary = summary
        self.suppress_alarm = suppress_alarm
        self.suppress_snmp_trap = suppress_snmp_trap
        self.threshold = threshold
        VapiStruct.__init__(self)


MonitoringEvent._set_binding_type(type.StructType(
    'com.vmware.nsx.model.monitoring_event', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'description_on_clear': type.OptionalType(type.StringType()),
        'entity_resource_type': type.OptionalType(type.StringType()),
        'event_false_snmp_oid': type.OptionalType(type.StringType()),
        'event_true_snmp_oid': type.OptionalType(type.StringType()),
        'event_type': type.OptionalType(type.StringType()),
        'event_type_display_name': type.OptionalType(type.StringType()),
        'feature_display_name': type.OptionalType(type.StringType()),
        'feature_name': type.OptionalType(type.StringType()),
        'is_disabled': type.OptionalType(type.BooleanType()),
        'is_threshold_fixed': type.OptionalType(type.BooleanType()),
        'node_types': type.OptionalType(type.ListType(type.StringType())),
        'recommended_action': type.OptionalType(type.StringType()),
        'sensitivity': type.OptionalType(type.IntegerType()),
        'severity': type.OptionalType(type.StringType()),
        'summary': type.OptionalType(type.StringType()),
        'suppress_alarm': type.OptionalType(type.BooleanType()),
        'suppress_snmp_trap': type.OptionalType(type.BooleanType()),
        'threshold': type.OptionalType(type.IntegerType()),
    },
    MonitoringEvent,
    False,
    None))



class MonthlyTelemetrySchedule(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'day_of_month': 'day_of_month',
                            'hour_of_day': 'hour_of_day',
                            'minutes': 'minutes',
                            'frequency_type': 'frequency_type',
                            }

    def __init__(self,
                 day_of_month=None,
                 hour_of_day=None,
                 minutes=None,
                 frequency_type=None,
                ):
        """
        :type  day_of_month: :class:`long` or ``None``
        :param day_of_month: Day of month on which data will be collected. Specify a value
            between 1 through 31. format: int64
        :type  hour_of_day: :class:`long` or ``None``
        :param hour_of_day: Hour at which data will be collected. Specify a value between 0
            through 23. format: int64
        :type  minutes: :class:`long` or ``None``
        :param minutes: Minute at which data will be collected. Specify a value between 0
            through 59. format: int64
        :type  frequency_type: :class:`str`
        :param frequency_type: Specify one of DailyTelemetrySchedule, WeeklyTelemetrySchedule, or
            MonthlyTelemetrySchedule.
        """
        self.day_of_month = day_of_month
        self.hour_of_day = hour_of_day
        self.minutes = minutes
        self._frequency_type = frequency_type
        VapiStruct.__init__(self)

    @property
    def frequency_type(self):
        """
        Return the discriminator value
        """
        return self._frequency_type

MonthlyTelemetrySchedule._set_binding_type(type.StructType(
    'com.vmware.nsx.model.monthly_telemetry_schedule', {
        'day_of_month': type.OptionalType(type.IntegerType()),
        'hour_of_day': type.OptionalType(type.IntegerType()),
        'minutes': type.OptionalType(type.IntegerType()),
        'frequency_type': type.StringType(),
    },
    MonthlyTelemetrySchedule,
    False,
    None))



class MsgClientInfo(VapiStruct):
    """
    Information about a messaging client

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'account_name': 'account_name',
                            'certificate': 'certificate',
                            'shared_secret': 'shared_secret',
                            'software_version': 'software_version',
                            }

    def __init__(self,
                 account_name=None,
                 certificate=None,
                 shared_secret=None,
                 software_version=None,
                ):
        """
        :type  account_name: :class:`str` or ``None``
        :param account_name: Account name for the messaging client. Identifies the client on the
            management plane message bus.
        :type  certificate: :class:`str` or ``None``
        :param certificate: Messaging client's certificate. Used to authenticate to the control
            plane messaging endpoint.
        :type  shared_secret: :class:`str` or ``None``
        :param shared_secret: Messaging client's secret. Used to authenticate to the management
            plane messaging broker.
        :type  software_version: :class:`str` or ``None``
        :param software_version: Software version of the node.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.account_name = account_name
        self.certificate = certificate
        self.shared_secret = shared_secret
        self.software_version = software_version
        VapiStruct.__init__(self)


MsgClientInfo._set_binding_type(type.StructType(
    'com.vmware.nsx.model.msg_client_info', {
        'account_name': type.OptionalType(type.StringType()),
        'certificate': type.OptionalType(type.StringType()),
        'shared_secret': type.OptionalType(type.StringType()),
        'software_version': type.OptionalType(type.StringType()),
    },
    MsgClientInfo,
    False,
    None))



class MultiWidgetConfiguration(VapiStruct):
    """
    Combines two or more widgetconfigurations into a multi-widget

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "MultiWidgetConfiguration"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'navigation': 'navigation',
                            'widgets': 'widgets',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'datasources': 'datasources',
                            'default_filter_value': 'default_filter_value',
                            'drilldown_id': 'drilldown_id',
                            'filter': 'filter',
                            'filter_value_required': 'filter_value_required',
                            'footer': 'footer',
                            'icons': 'icons',
                            'is_drilldown': 'is_drilldown',
                            'legend': 'legend',
                            'shared': 'shared',
                            'span': 'span',
                            'weight': 'weight',
                            }

    def __init__(self,
                 navigation=None,
                 widgets=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='MultiWidgetConfiguration',
                 tags=None,
                 datasources=None,
                 default_filter_value=None,
                 drilldown_id=None,
                 filter=None,
                 filter_value_required=None,
                 footer=None,
                 icons=None,
                 is_drilldown=None,
                 legend=None,
                 shared=None,
                 span=None,
                 weight=None,
                ):
        """
        :type  navigation: :class:`str` or ``None``
        :param navigation: Hyperlink of the specified UI page that provides details.
        :type  widgets: :class:`list` of :class:`WidgetItem` or ``None``
        :param widgets: Array of widgets that are part of the multi-widget.
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Title of the widget. If display_name is omitted, the widget will be
            shown without a title.
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_LABELVALUECONFIGURATION`
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_DONUTCONFIGURATION`
            *
              :attr:`WidgetConfiguration.RESOURCE_TYPE_MULTIWIDGETCONFIGURATION`
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_CONTAINERCONFIGURATION`
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_STATSCONFIGURATION`
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_GRIDCONFIGURATION`
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_GRAPHCONFIGURATION`
            *
              :attr:`WidgetConfiguration.RESOURCE_TYPE_CUSTOMWIDGETCONFIGURATION`
            *
              :attr:`WidgetConfiguration.RESOURCE_TYPE_DROPDOWNFILTERWIDGETCONFIGURATION`
            
            Supported visualization types are LabelValueConfiguration,
            DonutConfiguration, GridConfiguration, StatsConfiguration,
            MultiWidgetConfiguration, GraphConfiguration,
            ContainerConfiguration, CustomWidgetConfiguration and
            DropdownFilterWidgetConfiguration.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  datasources: :class:`list` of :class:`Datasource` or ``None``
        :param datasources: The 'datasources' represent the sources from which data will be
            fetched. Currently, only NSX-API is supported as a 'default'
            datasource. An example of specifying 'default' datasource along
            with the urls to fetch data from is given at 'example_request'
            section of 'CreateWidgetConfiguration' API.
        :type  default_filter_value: :class:`list` of :class:`DefaultFilterValue` or ``None``
        :param default_filter_value: Default filter values to be passed to datasources. This will be
            used when the report is requested without filter values.
        :type  drilldown_id: :class:`str` or ``None``
        :param drilldown_id: Id of drilldown widget, if any. Id should be a valid id of an
            existing widget. A widget is considered as drilldown widget when it
            is associated with any other widget and provides more detailed
            information about any data item from the parent widget.
        :type  filter: :class:`str` or ``None``
        :param filter: Id of filter widget for subscription, if any. Id should be a valid
            id of an existing filter widget. Filter widget should be from the
            same view. Datasource URLs should have placeholder values equal to
            filter alias to accept the filter value on filter change.
        :type  filter_value_required: :class:`bool` or ``None``
        :param filter_value_required: Flag to indicate that widget will continue to work without filter
            value. If this flag is set to false then default_filter_value is
            manadatory.
        :type  footer: :class:`Footer` or ``None``
        :param footer: 
        :type  icons: :class:`list` of :class:`Icon` or ``None``
        :param icons: Icons to be applied at dashboard for widgets and UI elements.
        :type  is_drilldown: :class:`bool` or ``None``
        :param is_drilldown: Set to true if this widget should be used as a drilldown.
        :type  legend: :class:`Legend` or ``None``
        :param legend: Legend to be displayed. If legend is not needed, do not include it.
        :type  shared: :class:`bool` or ``None``
        :param shared: Please use the property 'shared' of View instead of this. The
            widgets of a shared view are visible to other users.
        :type  span: :class:`long` or ``None``
        :param span: Represents the horizontal span of the widget / container. format:
            int32
        :type  weight: :class:`long` or ``None``
        :param weight: Specify relavite weight in WidgetItem for placement in a view.
            Please see WidgetItem for details. format: int32
        """
        self.navigation = navigation
        self.widgets = widgets
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        self.datasources = datasources
        self.default_filter_value = default_filter_value
        self.drilldown_id = drilldown_id
        self.filter = filter
        self.filter_value_required = filter_value_required
        self.footer = footer
        self.icons = icons
        self.is_drilldown = is_drilldown
        self.legend = legend
        self.shared = shared
        self.span = span
        self.weight = weight
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

MultiWidgetConfiguration._set_binding_type(type.StructType(
    'com.vmware.nsx.model.multi_widget_configuration', {
        'navigation': type.OptionalType(type.StringType()),
        'widgets': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'WidgetItem'))),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'datasources': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Datasource'))),
        'default_filter_value': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'DefaultFilterValue'))),
        'drilldown_id': type.OptionalType(type.StringType()),
        'filter': type.OptionalType(type.StringType()),
        'filter_value_required': type.OptionalType(type.BooleanType()),
        'footer': type.OptionalType(type.ReferenceType(__name__, 'Footer')),
        'icons': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Icon'))),
        'is_drilldown': type.OptionalType(type.BooleanType()),
        'legend': type.OptionalType(type.ReferenceType(__name__, 'Legend')),
        'shared': type.OptionalType(type.BooleanType()),
        'span': type.OptionalType(type.IntegerType()),
        'weight': type.OptionalType(type.IntegerType()),
    },
    MultiWidgetConfiguration,
    False,
    None))



class NDRAPrefixConfig(VapiStruct):
    """
    Overrides the router advertisement attributes for the IPv6 prefixes.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'network_prefix': 'network_prefix',
                            'prefix_preferred_time': 'prefix_preferred_time',
                            'prefix_valid_time': 'prefix_valid_time',
                            }

    def __init__(self,
                 network_prefix=None,
                 prefix_preferred_time=None,
                 prefix_valid_time=None,
                ):
        """
        :type  network_prefix: :class:`str` or ``None``
        :param network_prefix: Override the neighbor discovery prefix preferred time and prefix
            valid time for the subnet on uplink port whose network matches with
            the network address of CIDR specified in network_prefix. format:
            ipv6-cidr-block
        :type  prefix_preferred_time: :class:`long` or ``None``
        :param prefix_preferred_time: The time interval in seconds, in which the prefix is advertised as
            preferred. format: int64
        :type  prefix_valid_time: :class:`long` or ``None``
        :param prefix_valid_time: The time interval in seconds, in which the prefix is advertised as
            valid. format: int64
        """
        self.network_prefix = network_prefix
        self.prefix_preferred_time = prefix_preferred_time
        self.prefix_valid_time = prefix_valid_time
        VapiStruct.__init__(self)


NDRAPrefixConfig._set_binding_type(type.StructType(
    'com.vmware.nsx.model.NDRA_prefix_config', {
        'network_prefix': type.OptionalType(type.StringType()),
        'prefix_preferred_time': type.OptionalType(type.IntegerType()),
        'prefix_valid_time': type.OptionalType(type.IntegerType()),
    },
    NDRAPrefixConfig,
    False,
    None))



class NDRAProfile(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    RA_MODE_DISABLED = "DISABLED"
    """


    """
    RA_MODE_SLAAC_DNS_THROUGH_RA = "SLAAC_DNS_THROUGH_RA"
    """


    """
    RA_MODE_SLAAC_DNS_THROUGH_DHCP = "SLAAC_DNS_THROUGH_DHCP"
    """


    """
    RA_MODE_DHCP_ADDRESS_AND_DNS_THROUGH_DHCP = "DHCP_ADDRESS_AND_DNS_THROUGH_DHCP"
    """


    """
    RA_MODE_SLAAC_AND_ADDRESS_DNS_THROUGH_DHCP = "SLAAC_AND_ADDRESS_DNS_THROUGH_DHCP"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'dns_config': 'dns_config',
                            'ra_config': 'ra_config',
                            'ra_mode': 'ra_mode',
                            'reachable_timer': 'reachable_timer',
                            'retransmit_interval': 'retransmit_interval',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 dns_config=None,
                 ra_config=None,
                 ra_mode=None,
                 reachable_timer=None,
                 retransmit_interval=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  dns_config: :class:`RaDNSConfig` or ``None``
        :param dns_config: DNS Configuration
        :type  ra_config: :class:`RAConfig` or ``None``
        :param ra_config: RA Configuration
        :type  ra_mode: :class:`str` or ``None``
        :param ra_mode: Possible values are: 
            
            * :attr:`NDRAProfile.RA_MODE_DISABLED`
            * :attr:`NDRAProfile.RA_MODE_SLAAC_DNS_THROUGH_RA`
            * :attr:`NDRAProfile.RA_MODE_SLAAC_DNS_THROUGH_DHCP`
            * :attr:`NDRAProfile.RA_MODE_DHCP_ADDRESS_AND_DNS_THROUGH_DHCP`
            * :attr:`NDRAProfile.RA_MODE_SLAAC_AND_ADDRESS_DNS_THROUGH_DHCP`
            
             RA Mode
        :type  reachable_timer: :class:`long` or ``None``
        :param reachable_timer: Neighbour reachable time duration in milliseconds. A value of 0
            means unspecified. format: int64
        :type  retransmit_interval: :class:`long` or ``None``
        :param retransmit_interval: The time, in milliseconds, between retransmitted neighbour
            solicitation messages. format: int64
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.dns_config = dns_config
        self.ra_config = ra_config
        self.ra_mode = ra_mode
        self.reachable_timer = reachable_timer
        self.retransmit_interval = retransmit_interval
        VapiStruct.__init__(self)


NDRAProfile._set_binding_type(type.StructType(
    'com.vmware.nsx.model.NDRA_profile', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'dns_config': type.OptionalType(type.ReferenceType(__name__, 'RaDNSConfig')),
        'ra_config': type.OptionalType(type.ReferenceType(__name__, 'RAConfig')),
        'ra_mode': type.OptionalType(type.StringType()),
        'reachable_timer': type.OptionalType(type.IntegerType()),
        'retransmit_interval': type.OptionalType(type.IntegerType()),
    },
    NDRAProfile,
    False,
    None))



class NDRAProfileListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`NDRAProfile` or ``None``
        :param results: Paginated list of NDRAProfile
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


NDRAProfileListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.NDRA_profile_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NDRAProfile'))),
    },
    NDRAProfileListResult,
    False,
    None))



class NSAttributes(VapiStruct):
    """
    NS Attributes data holder structure

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'attributes_data': 'attributes_data',
                            'sub_attributes': 'sub_attributes',
                            }

    def __init__(self,
                 attributes_data=None,
                 sub_attributes=None,
                ):
        """
        :type  attributes_data: :class:`NSAttributesData` or ``None``
        :param attributes_data: Data for attribute
        :type  sub_attributes: :class:`list` of :class:`NSAttributesData` or ``None``
        :param sub_attributes: Reference to sub attributes for the attribute
        """
        self.attributes_data = attributes_data
        self.sub_attributes = sub_attributes
        VapiStruct.__init__(self)


NSAttributes._set_binding_type(type.StructType(
    'com.vmware.nsx.model.NS_attributes', {
        'attributes_data': type.OptionalType(type.ReferenceType(__name__, 'NSAttributesData')),
        'sub_attributes': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NSAttributesData'))),
    },
    NSAttributes,
    False,
    None))



class NSAttributesData(VapiStruct):
    """
    Attributes/sub-attributes data holder structure for NSProfile

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    ATTRIBUTE_SOURCE_SYSTEM = "SYSTEM"
    """


    """
    ATTRIBUTE_SOURCE_CUSTOM = "CUSTOM"
    """


    """
    DATATYPE_STRING = "STRING"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'attribute_source': 'attribute_source',
                            'datatype': 'datatype',
                            'key': 'key',
                            'value': 'value',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 attribute_source=None,
                 datatype=None,
                 key=None,
                 value=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description for NSProfile attributes
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  attribute_source: :class:`str` or ``None``
        :param attribute_source: Possible values are: 
            
            * :attr:`NSAttributesData.ATTRIBUTE_SOURCE_SYSTEM`
            * :attr:`NSAttributesData.ATTRIBUTE_SOURCE_CUSTOM`
            
             Attribute is predefined or custom
        :type  datatype: :class:`str` or ``None``
        :param datatype: Possible values are: 
            
            * :attr:`NSAttributesData.DATATYPE_STRING`
            
             Data type of attribute/sub attribute key
        :type  key: :class:`str` or ``None``
        :param key: NSProfile attribute/sub attribute keys.
        :type  value: :class:`list` of :class:`str` or ``None``
        :param value: Multiple attribute/sub attribute values can be specified as
            elements of array.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.attribute_source = attribute_source
        self.datatype = datatype
        self.key = key
        self.value = value
        VapiStruct.__init__(self)


NSAttributesData._set_binding_type(type.StructType(
    'com.vmware.nsx.model.NS_attributes_data', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'attribute_source': type.OptionalType(type.StringType()),
        'datatype': type.OptionalType(type.StringType()),
        'key': type.OptionalType(type.StringType()),
        'value': type.OptionalType(type.ListType(type.StringType())),
    },
    NSAttributesData,
    False,
    None))



class NSGroup(VapiStruct):
    """
    NSGroups are recursive groupings of different NSX elements (logical and
    physical), typically used in policy definitions.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'member_count': 'member_count',
                            'members': 'members',
                            'membership_criteria': 'membership_criteria',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 member_count=None,
                 members=None,
                 membership_criteria=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  member_count: :class:`long` or ``None``
        :param member_count: Count of the members added to this NSGroup format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  members: :class:`list` of :class:`NSGroupSimpleExpression` or ``None``
        :param members: Reference to the direct/static members of the NSGroup. Can be ID
            based expressions only. VirtualMachine cannot be added as a static
            member.
        :type  membership_criteria: :class:`list` of :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param membership_criteria: List of tag or name based expressions which define the dynamic
            membership criteria for this NSGroup. An object must satisfy
            atleast one of these expressions to qualify as a member of this
            group. It is not recommended to use ID based expressions in this
            section. ID based expression should be used in \"members\" section
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`NSGroupExpression`. When methods return a value of this
            class as a return value, the attribute will contain all the
            attributes defined in :class:`NSGroupExpression`.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.member_count = member_count
        self.members = members
        self.membership_criteria = membership_criteria
        VapiStruct.__init__(self)


NSGroup._set_binding_type(type.StructType(
    'com.vmware.nsx.model.NS_group', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'member_count': type.OptionalType(type.IntegerType()),
        'members': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NSGroupSimpleExpression'))),
        'membership_criteria': type.OptionalType(type.ListType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'NSGroupExpression')]))),
    },
    NSGroup,
    False,
    None))



class NSGroupComplexExpression(VapiStruct):
    """
    Complex expressions to represent NSGroup membership

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "NSGroupComplexExpression"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'expressions': 'expressions',
                            'resource_type': 'resource_type',
                            }

    def __init__(self,
                 expressions=None,
                 resource_type='NSGroupComplexExpression',
                ):
        """
        :type  expressions: :class:`list` of :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param expressions: Represents expressions which are to be logically 'AND'ed.The array
            cannot contain NSGroupComplexExpression.Only NSGroupTagExpression
            and NSGroupSimpleExpressions are accepted.
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`NSGroupExpression`. When methods return a value of this
            class as a return value, the attribute will contain all the
            attributes defined in :class:`NSGroupExpression`.
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`NSGroupExpression.RESOURCE_TYPE_NSGROUPSIMPLEEXPRESSION`
            * :attr:`NSGroupExpression.RESOURCE_TYPE_NSGROUPCOMPLEXEXPRESSION`
            * :attr:`NSGroupExpression.RESOURCE_TYPE_NSGROUPTAGEXPRESSION`
        """
        self.expressions = expressions
        self._resource_type = resource_type
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

NSGroupComplexExpression._set_binding_type(type.StructType(
    'com.vmware.nsx.model.NS_group_complex_expression', {
        'expressions': type.OptionalType(type.ListType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'NSGroupExpression')]))),
        'resource_type': type.StringType(),
    },
    NSGroupComplexExpression,
    False,
    None))



class NSGroupExpression(VapiStruct):
    """
    Policy expression for NSGroup membership

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "NSGroupExpression"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    RESOURCE_TYPE_NSGROUPSIMPLEEXPRESSION = "NSGroupSimpleExpression"
    """


    """
    RESOURCE_TYPE_NSGROUPCOMPLEXEXPRESSION = "NSGroupComplexExpression"
    """


    """
    RESOURCE_TYPE_NSGROUPTAGEXPRESSION = "NSGroupTagExpression"
    """


    """



    _canonical_to_pep_names = {
                            'resource_type': 'resource_type',
                            }

    def __init__(self,
                 resource_type='NSGroupExpression',
                ):
        """
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`NSGroupExpression.RESOURCE_TYPE_NSGROUPSIMPLEEXPRESSION`
            * :attr:`NSGroupExpression.RESOURCE_TYPE_NSGROUPCOMPLEXEXPRESSION`
            * :attr:`NSGroupExpression.RESOURCE_TYPE_NSGROUPTAGEXPRESSION`
        """
        self._resource_type = resource_type
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

NSGroupExpression._set_binding_type(type.StructType(
    'com.vmware.nsx.model.NS_group_expression', {
        'resource_type': type.StringType(),
    },
    NSGroupExpression,
    False,
    None))



class NSGroupExpressionList(VapiStruct):
    """
    List of NSGroupExpressions

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'members': 'members',
                            }

    def __init__(self,
                 members=None,
                ):
        """
        :type  members: :class:`list` of :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param members: List of NSGroupExpressions to be passed to add and remove APIs
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`NSGroupExpression`. When methods return a value of this
            class as a return value, the attribute will contain all the
            attributes defined in :class:`NSGroupExpression`.
        """
        self.members = members
        VapiStruct.__init__(self)


NSGroupExpressionList._set_binding_type(type.StructType(
    'com.vmware.nsx.model.NS_group_expression_list', {
        'members': type.OptionalType(type.ListType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'NSGroupExpression')]))),
    },
    NSGroupExpressionList,
    False,
    None))



class NSGroupInfo(VapiStruct):
    """
    NSGroupInfo contains information about a particular NSGroup used in a SI
    Rule. It also contains information about policy path used to create this
    NSGroup.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'nsgroup': 'nsgroup',
                            'nsgroup_policy_path': 'nsgroup_policy_path',
                            }

    def __init__(self,
                 nsgroup=None,
                 nsgroup_policy_path=None,
                ):
        """
        :type  nsgroup: :class:`ResourceReference` or ``None``
        :param nsgroup: NSGroup Data.
        :type  nsgroup_policy_path: :class:`str` or ``None``
        :param nsgroup_policy_path: Relative Policy path of a particular NSGroup.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.nsgroup = nsgroup
        self.nsgroup_policy_path = nsgroup_policy_path
        VapiStruct.__init__(self)


NSGroupInfo._set_binding_type(type.StructType(
    'com.vmware.nsx.model.NS_group_info', {
        'nsgroup': type.OptionalType(type.ReferenceType(__name__, 'ResourceReference')),
        'nsgroup_policy_path': type.OptionalType(type.StringType()),
    },
    NSGroupInfo,
    False,
    None))



class NSGroupListResult(VapiStruct):
    """
    Paged Collection of NSGroups

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`NSGroup` or ``None``
        :param results: NSGroup list results
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


NSGroupListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.NS_group_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NSGroup'))),
    },
    NSGroupListResult,
    False,
    None))



class NSGroupSimpleExpression(VapiStruct):
    """
    Simple expressions to represent NSGroup membership

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "NSGroupSimpleExpression"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    OP_EQUALS = "EQUALS"
    """


    """
    OP_CONTAINS = "CONTAINS"
    """


    """
    OP_STARTSWITH = "STARTSWITH"
    """


    """
    OP_ENDSWITH = "ENDSWITH"
    """


    """
    OP_NOTEQUALS = "NOTEQUALS"
    """


    """
    TARGET_TYPE_NSGROUP = "NSGroup"
    """


    """
    TARGET_TYPE_IPSET = "IPSet"
    """


    """
    TARGET_TYPE_MACSET = "MACSet"
    """


    """
    TARGET_TYPE_LOGICALSWITCH = "LogicalSwitch"
    """


    """
    TARGET_TYPE_LOGICALPORT = "LogicalPort"
    """


    """
    TARGET_TYPE_VIRTUALMACHINE = "VirtualMachine"
    """


    """
    TARGET_TYPE_DIRECTORYGROUP = "DirectoryGroup"
    """


    """
    TARGET_TYPE_VIRTUALNETWORKINTERFACE = "VirtualNetworkInterface"
    """


    """
    TARGET_TYPE_TRANSPORTNODE = "TransportNode"
    """


    """
    TARGET_TYPE_CLOUDNATIVESERVICEINSTANCE = "CloudNativeServiceInstance"
    """


    """
    TARGET_TYPE_PHYSICALSERVER = "PhysicalServer"
    """


    """



    _canonical_to_pep_names = {
                            'op': 'op',
                            'target_property': 'target_property',
                            'target_resource': 'target_resource',
                            'target_type': 'target_type',
                            'value': 'value',
                            'resource_type': 'resource_type',
                            }

    def __init__(self,
                 op=None,
                 target_property=None,
                 target_resource=None,
                 target_type=None,
                 value=None,
                 resource_type='NSGroupSimpleExpression',
                ):
        """
        :type  op: :class:`str` or ``None``
        :param op: Possible values are: 
            
            * :attr:`NSGroupSimpleExpression.OP_EQUALS`
            * :attr:`NSGroupSimpleExpression.OP_CONTAINS`
            * :attr:`NSGroupSimpleExpression.OP_STARTSWITH`
            * :attr:`NSGroupSimpleExpression.OP_ENDSWITH`
            * :attr:`NSGroupSimpleExpression.OP_NOTEQUALS`
            
             All operators perform a case insensitive match.
        :type  target_property: :class:`str` or ``None``
        :param target_property: Field of the resource on which this expression is evaluated
        :type  target_resource: :class:`ResourceReference` or ``None``
        :param target_resource: Reference of the target. Will be populated when the property is a
            resource id, the op (operator) is EQUALS and populate_references is
            set to be true.
        :type  target_type: :class:`str` or ``None``
        :param target_type: Possible values are: 
            
            * :attr:`NSGroupSimpleExpression.TARGET_TYPE_NSGROUP`
            * :attr:`NSGroupSimpleExpression.TARGET_TYPE_IPSET`
            * :attr:`NSGroupSimpleExpression.TARGET_TYPE_MACSET`
            * :attr:`NSGroupSimpleExpression.TARGET_TYPE_LOGICALSWITCH`
            * :attr:`NSGroupSimpleExpression.TARGET_TYPE_LOGICALPORT`
            * :attr:`NSGroupSimpleExpression.TARGET_TYPE_VIRTUALMACHINE`
            * :attr:`NSGroupSimpleExpression.TARGET_TYPE_DIRECTORYGROUP`
            *
              :attr:`NSGroupSimpleExpression.TARGET_TYPE_VIRTUALNETWORKINTERFACE`
            * :attr:`NSGroupSimpleExpression.TARGET_TYPE_TRANSPORTNODE`
            *
              :attr:`NSGroupSimpleExpression.TARGET_TYPE_CLOUDNATIVESERVICEINSTANCE`
            * :attr:`NSGroupSimpleExpression.TARGET_TYPE_PHYSICALSERVER`
            
             Type of the resource on which this expression is evaluated
        :type  value: :class:`str` or ``None``
        :param value: Value that satisfies this expression
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`NSGroupExpression.RESOURCE_TYPE_NSGROUPSIMPLEEXPRESSION`
            * :attr:`NSGroupExpression.RESOURCE_TYPE_NSGROUPCOMPLEXEXPRESSION`
            * :attr:`NSGroupExpression.RESOURCE_TYPE_NSGROUPTAGEXPRESSION`
        """
        self.op = op
        self.target_property = target_property
        self.target_resource = target_resource
        self.target_type = target_type
        self.value = value
        self._resource_type = resource_type
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

NSGroupSimpleExpression._set_binding_type(type.StructType(
    'com.vmware.nsx.model.NS_group_simple_expression', {
        'op': type.OptionalType(type.StringType()),
        'target_property': type.OptionalType(type.StringType()),
        'target_resource': type.OptionalType(type.ReferenceType(__name__, 'ResourceReference')),
        'target_type': type.OptionalType(type.StringType()),
        'value': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
    },
    NSGroupSimpleExpression,
    False,
    None))



class NSGroupTagExpression(VapiStruct):
    """
    Includes both scope and tag attribute of Tag. The scope and tag expressions
    are logically 'AND' with each other. eg- tag.scope = \"S1\" AND tag.tag =
    'T1'

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "NSGroupTagExpression"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    SCOPE_OP_EQUALS = "EQUALS"
    """


    """
    TAG_OP_EQUALS = "EQUALS"
    """


    """
    TAG_OP_CONTAINS = "CONTAINS"
    """


    """
    TAG_OP_STARTSWITH = "STARTSWITH"
    """


    """
    TAG_OP_ENDSWITH = "ENDSWITH"
    """


    """
    TARGET_TYPE_LOGICALSWITCH = "LogicalSwitch"
    """


    """
    TARGET_TYPE_LOGICALPORT = "LogicalPort"
    """


    """
    TARGET_TYPE_VIRTUALMACHINE = "VirtualMachine"
    """


    """
    TARGET_TYPE_IPSET = "IPSet"
    """


    """



    _canonical_to_pep_names = {
                            'scope': 'scope',
                            'scope_op': 'scope_op',
                            'tag': 'tag',
                            'tag_op': 'tag_op',
                            'target_type': 'target_type',
                            'resource_type': 'resource_type',
                            }

    def __init__(self,
                 scope=None,
                 scope_op=None,
                 tag=None,
                 tag_op=None,
                 target_type=None,
                 resource_type='NSGroupTagExpression',
                ):
        """
        :type  scope: :class:`str` or ``None``
        :param scope: The tag.scope attribute of the object
        :type  scope_op: :class:`str` or ``None``
        :param scope_op: Possible values are: 
            
            * :attr:`NSGroupTagExpression.SCOPE_OP_EQUALS`
            
             Operator of the scope expression eg- tag.scope = \"S1\".
        :type  tag: :class:`str` or ``None``
        :param tag: The tag.tag attribute of the object
        :type  tag_op: :class:`str` or ``None``
        :param tag_op: Possible values are: 
            
            * :attr:`NSGroupTagExpression.TAG_OP_EQUALS`
            * :attr:`NSGroupTagExpression.TAG_OP_CONTAINS`
            * :attr:`NSGroupTagExpression.TAG_OP_STARTSWITH`
            * :attr:`NSGroupTagExpression.TAG_OP_ENDSWITH`
            
            Target_type VirtualMachine supports all specified operators for tag
            expression while LogicalSwitch and LogicalPort supports only EQUALS
            operator. All operators perform a case insensitive match.
        :type  target_type: :class:`str` or ``None``
        :param target_type: Possible values are: 
            
            * :attr:`NSGroupTagExpression.TARGET_TYPE_LOGICALSWITCH`
            * :attr:`NSGroupTagExpression.TARGET_TYPE_LOGICALPORT`
            * :attr:`NSGroupTagExpression.TARGET_TYPE_VIRTUALMACHINE`
            * :attr:`NSGroupTagExpression.TARGET_TYPE_IPSET`
            
             Type of the resource on which this expression is evaluated
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`NSGroupExpression.RESOURCE_TYPE_NSGROUPSIMPLEEXPRESSION`
            * :attr:`NSGroupExpression.RESOURCE_TYPE_NSGROUPCOMPLEXEXPRESSION`
            * :attr:`NSGroupExpression.RESOURCE_TYPE_NSGROUPTAGEXPRESSION`
        """
        self.scope = scope
        self.scope_op = scope_op
        self.tag = tag
        self.tag_op = tag_op
        self.target_type = target_type
        self._resource_type = resource_type
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

NSGroupTagExpression._set_binding_type(type.StructType(
    'com.vmware.nsx.model.NS_group_tag_expression', {
        'scope': type.OptionalType(type.StringType()),
        'scope_op': type.OptionalType(type.StringType()),
        'tag': type.OptionalType(type.StringType()),
        'tag_op': type.OptionalType(type.StringType()),
        'target_type': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
    },
    NSGroupTagExpression,
    False,
    None))



class NSProfile(VapiStruct):
    """
    An entity that encapsulates attributes and sub-attributes of various
    network services (ex. L7 services,domain name,encryption algorithm) The
    entity will be consumed in DFW rules and can be added in new tuple called
    profile in DFW rules. This entity is design to be generic and can be
    consumed at other places as well where attributes and sub-attributes
    collection can be used. To get a list of supported attributes and
    sub-attributes fire the following REST API GET
    https://&lt;nsx-mgr&gt;/api/v1/ns-profiles/attributes

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'is_valid': 'is_valid',
                            'nsprofile_attribute': 'nsprofile_attribute',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 is_valid=None,
                 nsprofile_attribute=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  is_valid: :class:`bool` or ``None``
        :param is_valid: If set to false, the NSProfile has some app ids which are
            unsupported. Those were allowed to be added in previous releases
            but in testing in later phases found that those app ids could not
            be detected.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  nsprofile_attribute: :class:`list` of :class:`NSAttributes` or ``None``
        :param nsprofile_attribute: Reference to the encapsulating object of attributes/sub-attributes
            for NSProfile.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.is_valid = is_valid
        self.nsprofile_attribute = nsprofile_attribute
        VapiStruct.__init__(self)


NSProfile._set_binding_type(type.StructType(
    'com.vmware.nsx.model.NS_profile', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'is_valid': type.OptionalType(type.BooleanType()),
        'nsprofile_attribute': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NSAttributes'))),
    },
    NSProfile,
    False,
    None))



class NSProfileListResult(VapiStruct):
    """
    List result of NSProfiles

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`NSProfile` or ``None``
        :param results: Paged collection of NSProfiles
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


NSProfileListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.NS_profile_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NSProfile'))),
    },
    NSProfileListResult,
    False,
    None))



class NSService(VapiStruct):
    """
    A Networking and Security Service allows users to specify characteristics
    to use for matching network traffic. For example the user can specify port
    and protocol pair.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'default_service': 'default_service',
                            'nsservice_element': 'nsservice_element',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 default_service=None,
                 nsservice_element=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  default_service: :class:`bool` or ``None``
        :param default_service: The default NSServices are created in the system by default. These
            NSServices can't be modified/deleted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  nsservice_element: :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param nsservice_element: An NSService Element that describes traffic corresponding to this
            NSService
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`NSServiceElement`. When methods return a value of this
            class as a return value, the attribute will contain all the
            attributes defined in :class:`NSServiceElement`.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.default_service = default_service
        self.nsservice_element = nsservice_element
        VapiStruct.__init__(self)


NSService._set_binding_type(type.StructType(
    'com.vmware.nsx.model.NS_service', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'default_service': type.OptionalType(type.BooleanType()),
        'nsservice_element': type.OptionalType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'NSServiceElement')])),
    },
    NSService,
    False,
    None))



class NSServiceElement(VapiStruct):
    """
    An NSService element that describes traffic corresponding to an NSService

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "NSServiceElement"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    RESOURCE_TYPE_ETHERTYPENSSERVICE = "EtherTypeNSService"
    """


    """
    RESOURCE_TYPE_IPPROTOCOLNSSERVICE = "IPProtocolNSService"
    """


    """
    RESOURCE_TYPE_IGMPTYPENSSERVICE = "IGMPTypeNSService"
    """


    """
    RESOURCE_TYPE_ICMPTYPENSSERVICE = "ICMPTypeNSService"
    """


    """
    RESOURCE_TYPE_ALGTYPENSSERVICE = "ALGTypeNSService"
    """


    """
    RESOURCE_TYPE_L4PORTSETNSSERVICE = "L4PortSetNSService"
    """


    """



    _canonical_to_pep_names = {
                            'resource_type': 'resource_type',
                            }

    def __init__(self,
                 resource_type='NSServiceElement',
                ):
        """
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`NSServiceElement.RESOURCE_TYPE_ETHERTYPENSSERVICE`
            * :attr:`NSServiceElement.RESOURCE_TYPE_IPPROTOCOLNSSERVICE`
            * :attr:`NSServiceElement.RESOURCE_TYPE_IGMPTYPENSSERVICE`
            * :attr:`NSServiceElement.RESOURCE_TYPE_ICMPTYPENSSERVICE`
            * :attr:`NSServiceElement.RESOURCE_TYPE_ALGTYPENSSERVICE`
            * :attr:`NSServiceElement.RESOURCE_TYPE_L4PORTSETNSSERVICE`
            
             The specific type of NSServiceElement
        """
        self._resource_type = resource_type
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

NSServiceElement._set_binding_type(type.StructType(
    'com.vmware.nsx.model.NS_service_element', {
        'resource_type': type.StringType(),
    },
    NSServiceElement,
    False,
    None))



class NSServiceGroup(VapiStruct):
    """
    A Networking and Security Service Group that represents a group of
    NSServices

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    SERVICE_TYPE_ETHER = "ETHER"
    """


    """
    SERVICE_TYPE_NON_ETHER = "NON_ETHER"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'default_service': 'default_service',
                            'members': 'members',
                            'service_type': 'service_type',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 default_service=None,
                 members=None,
                 service_type=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  default_service: :class:`bool` or ``None``
        :param default_service: The default NSServiceGroups are created in the system by default.
            These NSServiceGroups can't be modified/deleted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  members: :class:`list` of :class:`ResourceReference` or ``None``
        :param members: List of NSService resources that can be added as members to an
            NSServiceGroup.
        :type  service_type: :class:`str` or ``None``
        :param service_type: Possible values are: 
            
            * :attr:`NSServiceGroup.SERVICE_TYPE_ETHER`
            * :attr:`NSServiceGroup.SERVICE_TYPE_NON_ETHER`
            
             Type of the NSServiceGroup
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.default_service = default_service
        self.members = members
        self.service_type = service_type
        VapiStruct.__init__(self)


NSServiceGroup._set_binding_type(type.StructType(
    'com.vmware.nsx.model.NS_service_group', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'default_service': type.OptionalType(type.BooleanType()),
        'members': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceReference'))),
        'service_type': type.OptionalType(type.StringType()),
    },
    NSServiceGroup,
    False,
    None))



class NSServiceGroupListResult(VapiStruct):
    """
    List result of NSServiceGroups

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`NSServiceGroup` or ``None``
        :param results: Paged collection of NSServiceGroups
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


NSServiceGroupListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.NS_service_group_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NSServiceGroup'))),
    },
    NSServiceGroupListResult,
    False,
    None))



class NSServiceListResult(VapiStruct):
    """
    List result of NSservices

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`NSService` or ``None``
        :param results: Paged collection of NSServices
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


NSServiceListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.NS_service_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NSService'))),
    },
    NSServiceListResult,
    False,
    None))



class NSSupportedAttributeTypesResult(VapiStruct):
    """
    NSSupportedAttributes Types

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'attribute_types': 'attribute_types',
                            }

    def __init__(self,
                 attribute_types=None,
                ):
        """
        :type  attribute_types: :class:`list` of :class:`str` or ``None``
        :param attribute_types: List of NSSupportedAttributes types
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.attribute_types = attribute_types
        VapiStruct.__init__(self)


NSSupportedAttributeTypesResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.NS_supported_attribute_types_result', {
        'attribute_types': type.OptionalType(type.ListType(type.StringType())),
    },
    NSSupportedAttributeTypesResult,
    False,
    None))



class NSSupportedAttributes(VapiStruct):
    """
    Supported attributes and sub-attributes for NSProfile

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'ns_attributes': 'ns_attributes',
                            }

    def __init__(self,
                 ns_attributes=None,
                ):
        """
        :type  ns_attributes: :class:`list` of :class:`NSAttributes` or ``None``
        :param ns_attributes: The type represent pre-defined or user defined list of supported
            attributes and sub-attributes that can be used while creating
            NSProfile
        """
        self.ns_attributes = ns_attributes
        VapiStruct.__init__(self)


NSSupportedAttributes._set_binding_type(type.StructType(
    'com.vmware.nsx.model.NS_supported_attributes', {
        'ns_attributes': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NSAttributes'))),
    },
    NSSupportedAttributes,
    False,
    None))



class NSSupportedAttributesListResult(VapiStruct):
    """
    NSSupportedAttributes for supported attributes and sub-attributes

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`NSSupportedAttributes` or ``None``
        :param results: Paged collection of NSSupportedAttributes
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


NSSupportedAttributesListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.NS_supported_attributes_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NSSupportedAttributes'))),
    },
    NSSupportedAttributesListResult,
    False,
    None))



class NSXProfileReference(VapiStruct):
    """
    It is a reference to any NSX profile. It comprise of NSX profile type eg.
    DFWCPUProfile, CentralConfigProfile etc. and id of profile i.e. target_id

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    PROFILE_TYPE_FIREWALLSESSIONTIMERPROFILE = "FirewallSessionTimerProfile"
    """


    """
    PROFILE_TYPE_FIREWALLCPUMEMTHRESHOLDSPROFILE = "FirewallCpuMemThresholdsProfile"
    """


    """
    PROFILE_TYPE_GISERVICEPROFILE = "GiServiceProfile"
    """


    """
    PROFILE_TYPE_FIREWALLFLOODPROTECTIONPROFILE = "FirewallFloodProtectionProfile"
    """


    """
    PROFILE_TYPE_FIREWALLDNSPROFILE = "FirewallDnsProfile"
    """


    """
    PROFILE_TYPE_LATENCYSTATPROFILE = "LatencyStatProfile"
    """


    """
    PROFILE_TYPE_SHAPROFILE = "SHAProfile"
    """


    """
    PROFILE_TYPE_IPDISCOVERYSWITCHINGUPMPROFILE = "IpDiscoverySwitchingUpmProfile"
    """


    """
    PROFILE_TYPE_SYSTEMHEALTHPLUGINPROFILE = "SystemHealthPluginProfile"
    """


    """



    _canonical_to_pep_names = {
                            'is_valid': 'is_valid',
                            'target_display_name': 'target_display_name',
                            'target_id': 'target_id',
                            'target_type': 'target_type',
                            'profile_type': 'profile_type',
                            }

    def __init__(self,
                 is_valid=None,
                 target_display_name=None,
                 target_id=None,
                 target_type=None,
                 profile_type=None,
                ):
        """
        :type  is_valid: :class:`bool` or ``None``
        :param is_valid: Will be set to false if the referenced NSX resource has been
            deleted.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  target_display_name: :class:`str` or ``None``
        :param target_display_name: Display name of the NSX resource.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  target_id: :class:`str` or ``None``
        :param target_id: Identifier of the NSX resource.
        :type  target_type: :class:`str` or ``None``
        :param target_type: Type of the NSX resource.
        :type  profile_type: :class:`str` or ``None``
        :param profile_type: Possible values are: 
            
            *
              :attr:`NSXProfileReference.PROFILE_TYPE_FIREWALLSESSIONTIMERPROFILE`
            *
              :attr:`NSXProfileReference.PROFILE_TYPE_FIREWALLCPUMEMTHRESHOLDSPROFILE`
            * :attr:`NSXProfileReference.PROFILE_TYPE_GISERVICEPROFILE`
            *
              :attr:`NSXProfileReference.PROFILE_TYPE_FIREWALLFLOODPROTECTIONPROFILE`
            * :attr:`NSXProfileReference.PROFILE_TYPE_FIREWALLDNSPROFILE`
            * :attr:`NSXProfileReference.PROFILE_TYPE_LATENCYSTATPROFILE`
            * :attr:`NSXProfileReference.PROFILE_TYPE_SHAPROFILE`
            *
              :attr:`NSXProfileReference.PROFILE_TYPE_IPDISCOVERYSWITCHINGUPMPROFILE`
            *
              :attr:`NSXProfileReference.PROFILE_TYPE_SYSTEMHEALTHPLUGINPROFILE`
            
             Profile type of the ServiceConfig
        """
        self.is_valid = is_valid
        self.target_display_name = target_display_name
        self.target_id = target_id
        self.target_type = target_type
        self.profile_type = profile_type
        VapiStruct.__init__(self)


NSXProfileReference._set_binding_type(type.StructType(
    'com.vmware.nsx.model.NSX_profile_reference', {
        'is_valid': type.OptionalType(type.BooleanType()),
        'target_display_name': type.OptionalType(type.StringType()),
        'target_id': type.OptionalType(type.StringType()),
        'target_type': type.OptionalType(type.StringType()),
        'profile_type': type.OptionalType(type.StringType()),
    },
    NSXProfileReference,
    False,
    None))



class NamedTeamingPolicy(VapiStruct):
    """
    Uplink Teaming Policy with a name that can be referenced by logical
    switches

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    POLICY_FAILOVER_ORDER = "FAILOVER_ORDER"
    """


    """
    POLICY_LOADBALANCE_SRCID = "LOADBALANCE_SRCID"
    """


    """
    POLICY_LOADBALANCE_SRC_MAC = "LOADBALANCE_SRC_MAC"
    """


    """



    _canonical_to_pep_names = {
                            'active_list': 'active_list',
                            'policy': 'policy',
                            'standby_list': 'standby_list',
                            'name': 'name',
                            }

    def __init__(self,
                 active_list=None,
                 policy=None,
                 standby_list=None,
                 name=None,
                ):
        """
        :type  active_list: :class:`list` of :class:`Uplink` or ``None``
        :param active_list: List of Uplinks used in active list
        :type  policy: :class:`str` or ``None``
        :param policy: Possible values are: 
            
            * :attr:`NamedTeamingPolicy.POLICY_FAILOVER_ORDER`
            * :attr:`NamedTeamingPolicy.POLICY_LOADBALANCE_SRCID`
            * :attr:`NamedTeamingPolicy.POLICY_LOADBALANCE_SRC_MAC`
            
             Teaming policy
        :type  standby_list: :class:`list` of :class:`Uplink` or ``None``
        :param standby_list: List of Uplinks used in standby list
        :type  name: :class:`str` or ``None``
        :param name: An uplink teaming policy of a given name defined in
            UplinkHostSwitchProfile. The names of all NamedTeamingPolicies in
            an UplinkHostSwitchProfile must be different, but a name can be
            shared by different UplinkHostSwitchProfiles. Different
            TransportNodes can use different NamedTeamingPolicies having the
            same name in different UplinkHostSwitchProfiles to realize an
            uplink teaming policy on a logical switch. An uplink teaming policy
            on a logical switch can be any policy defined by a user; it does
            not have to be a single type of FAILOVER or LOADBALANCE. It can be
            a combination of types, for instance, a user can define a policy
            with name \"MyHybridTeamingPolicy\" as \"FAILOVER on all ESX
            TransportNodes and LOADBALANCE on all KVM TransportNodes\". The
            name is the key of the teaming policy and can not be changed once
            assigned.
        """
        self.active_list = active_list
        self.policy = policy
        self.standby_list = standby_list
        self.name = name
        VapiStruct.__init__(self)


NamedTeamingPolicy._set_binding_type(type.StructType(
    'com.vmware.nsx.model.named_teaming_policy', {
        'active_list': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Uplink'))),
        'policy': type.OptionalType(type.StringType()),
        'standby_list': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Uplink'))),
        'name': type.OptionalType(type.StringType()),
    },
    NamedTeamingPolicy,
    False,
    None))



class NatCounters(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'active_sessions': 'active_sessions',
                            'total_bytes': 'total_bytes',
                            'total_packets': 'total_packets',
                            }

    def __init__(self,
                 active_sessions=None,
                 total_bytes=None,
                 total_packets=None,
                ):
        """
        :type  active_sessions: :class:`long` or ``None``
        :param active_sessions: The number of active sessions format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  total_bytes: :class:`long` or ``None``
        :param total_bytes: The number of bytes format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  total_packets: :class:`long` or ``None``
        :param total_packets: The number of packets format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.active_sessions = active_sessions
        self.total_bytes = total_bytes
        self.total_packets = total_packets
        VapiStruct.__init__(self)


NatCounters._set_binding_type(type.StructType(
    'com.vmware.nsx.model.nat_counters', {
        'active_sessions': type.OptionalType(type.IntegerType()),
        'total_bytes': type.OptionalType(type.IntegerType()),
        'total_packets': type.OptionalType(type.IntegerType()),
    },
    NatCounters,
    False,
    None))



class NatRule(VapiStruct):
    """
    The configuration entity to define a NAT rule. It defines how an ip packet
    is matched via source address or/and destination address or/and service(s),
    how the address (and/or) port is translated, and how the related firewall
    stage is involved or bypassed.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    ACTION_SNAT = "SNAT"
    """


    """
    ACTION_DNAT = "DNAT"
    """


    """
    ACTION_REFLEXIVE = "REFLEXIVE"
    """


    """
    ACTION_NO_SNAT = "NO_SNAT"
    """


    """
    ACTION_NO_DNAT = "NO_DNAT"
    """


    """
    ACTION_NAT64 = "NAT64"
    """


    """
    FIREWALL_MATCH_MATCH_EXTERNAL_ADDRESS = "MATCH_EXTERNAL_ADDRESS"
    """


    """
    FIREWALL_MATCH_MATCH_INTERNAL_ADDRESS = "MATCH_INTERNAL_ADDRESS"
    """


    """
    FIREWALL_MATCH_BYPASS = "BYPASS"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'action': 'action',
                            'applied_tos': 'applied_tos',
                            'enabled': 'enabled',
                            'firewall_match': 'firewall_match',
                            'internal_rule_id': 'internal_rule_id',
                            'logging': 'logging',
                            'logical_router_id': 'logical_router_id',
                            'match_destination_network': 'match_destination_network',
                            'match_service': 'match_service',
                            'match_source_network': 'match_source_network',
                            'nat_pass': 'nat_pass',
                            'rule_priority': 'rule_priority',
                            'translated_network': 'translated_network',
                            'translated_ports': 'translated_ports',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 action=None,
                 applied_tos=None,
                 enabled=None,
                 firewall_match=None,
                 internal_rule_id=None,
                 logging=None,
                 logical_router_id=None,
                 match_destination_network=None,
                 match_service=None,
                 match_source_network=None,
                 nat_pass=None,
                 rule_priority=None,
                 translated_network=None,
                 translated_ports=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  action: :class:`str` or ``None``
        :param action: Possible values are: 
            
            * :attr:`NatRule.ACTION_SNAT`
            * :attr:`NatRule.ACTION_DNAT`
            * :attr:`NatRule.ACTION_REFLEXIVE`
            * :attr:`NatRule.ACTION_NO_SNAT`
            * :attr:`NatRule.ACTION_NO_DNAT`
            * :attr:`NatRule.ACTION_NAT64`
            
            Valid actions: SNAT, DNAT, NO_SNAT, NO_DNAT, REFLEXIVE, NAT64. All
            rules in a logical router are either stateless or stateful. Mix is
            not supported. SNAT and DNAT are stateful, can NOT be supported
            when the logical router is running at active-active HA mode;
            REFLEXIVE is stateless. NO_SNAT and NO_DNAT have no
            translated_fields, only match fields are supported.
        :type  applied_tos: :class:`list` of :class:`ResourceReference` or ``None``
        :param applied_tos: Holds the list of LogicalRouterPort Ids that a NAT rule can be
            applied to. The LogicalRouterPort used must belong to the same
            LogicalRouter for which the NAT Rule is created. As of now a NAT
            rule can only have a single LogicalRouterPort as applied_tos. When
            applied_tos is not set, the NAT rule is applied to all
            LogicalRouterPorts beloging to the LogicalRouter.
        :type  enabled: :class:`bool` or ``None``
        :param enabled: Indicator to enable/disable the rule.
        :type  firewall_match: :class:`str` or ``None``
        :param firewall_match: Possible values are: 
            
            * :attr:`NatRule.FIREWALL_MATCH_MATCH_EXTERNAL_ADDRESS`
            * :attr:`NatRule.FIREWALL_MATCH_MATCH_INTERNAL_ADDRESS`
            * :attr:`NatRule.FIREWALL_MATCH_BYPASS`
            
            Indicate how firewall is applied to a traffic packet. Firewall can
            be bypassed, or be applied to external/internal address of NAT
            rule. The firewall_match will take priority over nat_pass. If the
            firewall_match is not provided, the nat_pass will be picked up.
        :type  internal_rule_id: :class:`str` or ``None``
        :param internal_rule_id: Internal NAT rule uuid for debug used in Controller and backend.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  logging: :class:`bool` or ``None``
        :param logging: Enable/disable the logging of rule.
        :type  logical_router_id: :class:`str` or ``None``
        :param logical_router_id: The logical router id which the nat rule runs on.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  match_destination_network: :class:`str` or ``None``
        :param match_destination_network: IP Address | CIDR | (null implies Any)
        :type  match_service: :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param match_service: A NSServiceElement that specifies the matching services of source
            ports, destination ports, ip protocol version and number, sub
            protocol version and number, ICMP type and code, etc. The
            match_service can be one of IPProtocolNSService,L4PortSetNSService
            or ICMPTypeNSService. REFLEXIVE NAT does not support match_service.
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`NSServiceElement`. When methods return a value of this
            class as a return value, the attribute will contain all the
            attributes defined in :class:`NSServiceElement`.
        :type  match_source_network: :class:`str` or ``None``
        :param match_source_network: IP Address | CIDR | (null implies Any)
        :type  nat_pass: :class:`bool` or ``None``
        :param nat_pass: Default is true. If the nat_pass is set to true, the following
            firewall stage will be skipped. Please note, if action is NO_SNAT
            or NO_DNAT, then nat_pass must be set to true or omitted. Nat_pass
            was deprecated with an alternative firewall_match. Please stop
            using nat_pass to specify whether firewall stage is skipped. if you
            want to skip, please set firewall_match to BYPASS. If you do not
            want to skip, please set the firewall_match to
            MATCH_EXTERNAL_ADDRESS or MATCH_INTERNAL_ADDRESS. Please note, the
            firewall_match will take priority over the nat_pass. If both are
            provided, the nat_pass is ignored. If firewall_match is not
            provided while the nat_pass is specified, the nat_pass will still
            be picked up. In this case, if nat_pass is set to false, firewall
            rule will be applied on internall address of a packet, i.e.
            MATCH_INTERNAL_ADDRESS.
        :type  rule_priority: :class:`long` or ``None``
        :param rule_priority: Ascending, valid range [0-2147483647]. If multiple rules have the
            same priority, evaluation sequence is undefined. format: int64
        :type  translated_network: :class:`str` or ``None``
        :param translated_network: The translated address for the matched IP packet. For a SNAT, it
            can be a single ip address, an ip range, or a CIDR block. For a
            DNAT and a REFLEXIVE, it can be a single ip address or a CIDR
            block. Translated network is not supported for NO_SNAT or NO_DNAT.
        :type  translated_ports: :class:`str` or ``None``
        :param translated_ports: The translated port(s) for the mtached IP packet. It can be a
            single port or a port range. Please note, port translating is
            supported only for DNAT.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.action = action
        self.applied_tos = applied_tos
        self.enabled = enabled
        self.firewall_match = firewall_match
        self.internal_rule_id = internal_rule_id
        self.logging = logging
        self.logical_router_id = logical_router_id
        self.match_destination_network = match_destination_network
        self.match_service = match_service
        self.match_source_network = match_source_network
        self.nat_pass = nat_pass
        self.rule_priority = rule_priority
        self.translated_network = translated_network
        self.translated_ports = translated_ports
        VapiStruct.__init__(self)


NatRule._set_binding_type(type.StructType(
    'com.vmware.nsx.model.nat_rule', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'action': type.OptionalType(type.StringType()),
        'applied_tos': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceReference'))),
        'enabled': type.OptionalType(type.BooleanType()),
        'firewall_match': type.OptionalType(type.StringType()),
        'internal_rule_id': type.OptionalType(type.StringType()),
        'logging': type.OptionalType(type.BooleanType()),
        'logical_router_id': type.OptionalType(type.StringType()),
        'match_destination_network': type.OptionalType(type.StringType()),
        'match_service': type.OptionalType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'NSServiceElement')])),
        'match_source_network': type.OptionalType(type.StringType()),
        'nat_pass': type.OptionalType(type.BooleanType()),
        'rule_priority': type.OptionalType(type.IntegerType()),
        'translated_network': type.OptionalType(type.StringType()),
        'translated_ports': type.OptionalType(type.StringType()),
    },
    NatRule,
    False,
    None))



class NatRuleList(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'rules': 'rules',
                            }

    def __init__(self,
                 rules=None,
                ):
        """
        :type  rules: :class:`list` of :class:`NatRule` or ``None``
        :param rules: Add new NatRules to the list in Bulk creation.
        """
        self.rules = rules
        VapiStruct.__init__(self)


NatRuleList._set_binding_type(type.StructType(
    'com.vmware.nsx.model.nat_rule_list', {
        'rules': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NatRule'))),
    },
    NatRuleList,
    False,
    None))



class NatRuleListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`NatRule` or ``None``
        :param results: NAT rule list results
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


NatRuleListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.nat_rule_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NatRule'))),
    },
    NatRuleListResult,
    False,
    None))



class NatStatisticsPerLogicalRouter(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'last_update_timestamp': 'last_update_timestamp',
                            'logical_router_id': 'logical_router_id',
                            'per_transport_node_statistics': 'per_transport_node_statistics',
                            'statistics_across_all_nodes': 'statistics_across_all_nodes',
                            }

    def __init__(self,
                 last_update_timestamp=None,
                 logical_router_id=None,
                 per_transport_node_statistics=None,
                 statistics_across_all_nodes=None,
                ):
        """
        :type  last_update_timestamp: :class:`long` or ``None``
        :param last_update_timestamp: Timestamp when the data was last updated; unset if data source has
            never updated the data. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  logical_router_id: :class:`str` or ``None``
        :param logical_router_id: Id for the logical router
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  per_transport_node_statistics: :class:`list` of :class:`NatStatisticsPerTransportNode` or ``None``
        :param per_transport_node_statistics: Detailed per node statistics
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  statistics_across_all_nodes: :class:`NatCounters` or ``None``
        :param statistics_across_all_nodes: Rolled-up statistics for all rules on the logical router across all
            the nodes
        """
        self.last_update_timestamp = last_update_timestamp
        self.logical_router_id = logical_router_id
        self.per_transport_node_statistics = per_transport_node_statistics
        self.statistics_across_all_nodes = statistics_across_all_nodes
        VapiStruct.__init__(self)


NatStatisticsPerLogicalRouter._set_binding_type(type.StructType(
    'com.vmware.nsx.model.nat_statistics_per_logical_router', {
        'last_update_timestamp': type.OptionalType(type.IntegerType()),
        'logical_router_id': type.OptionalType(type.StringType()),
        'per_transport_node_statistics': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NatStatisticsPerTransportNode'))),
        'statistics_across_all_nodes': type.OptionalType(type.ReferenceType(__name__, 'NatCounters')),
    },
    NatStatisticsPerLogicalRouter,
    False,
    None))



class NatStatisticsPerRule(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'active_sessions': 'active_sessions',
                            'total_bytes': 'total_bytes',
                            'total_packets': 'total_packets',
                            'id': 'id',
                            'last_update_timestamp': 'last_update_timestamp',
                            'logical_router_id': 'logical_router_id',
                            'warning_message': 'warning_message',
                            }

    def __init__(self,
                 active_sessions=None,
                 total_bytes=None,
                 total_packets=None,
                 id=None,
                 last_update_timestamp=None,
                 logical_router_id=None,
                 warning_message=None,
                ):
        """
        :type  active_sessions: :class:`long` or ``None``
        :param active_sessions: The number of active sessions format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  total_bytes: :class:`long` or ``None``
        :param total_bytes: The number of bytes format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  total_packets: :class:`long` or ``None``
        :param total_packets: The number of packets format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  id: :class:`str` or ``None``
        :param id: The id of the NAT rule.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_update_timestamp: :class:`long` or ``None``
        :param last_update_timestamp: Timestamp when the data was last updated; unset if data source has
            never updated the data. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  logical_router_id: :class:`str` or ``None``
        :param logical_router_id: The id of the logical router which owns the NAT rule.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  warning_message: :class:`str` or ``None``
        :param warning_message: The warning message about the NAT Rule statistics.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.active_sessions = active_sessions
        self.total_bytes = total_bytes
        self.total_packets = total_packets
        self.id = id
        self.last_update_timestamp = last_update_timestamp
        self.logical_router_id = logical_router_id
        self.warning_message = warning_message
        VapiStruct.__init__(self)


NatStatisticsPerRule._set_binding_type(type.StructType(
    'com.vmware.nsx.model.nat_statistics_per_rule', {
        'active_sessions': type.OptionalType(type.IntegerType()),
        'total_bytes': type.OptionalType(type.IntegerType()),
        'total_packets': type.OptionalType(type.IntegerType()),
        'id': type.OptionalType(type.StringType()),
        'last_update_timestamp': type.OptionalType(type.IntegerType()),
        'logical_router_id': type.OptionalType(type.StringType()),
        'warning_message': type.OptionalType(type.StringType()),
    },
    NatStatisticsPerRule,
    False,
    None))



class NatStatisticsPerTransportNode(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'active_sessions': 'active_sessions',
                            'total_bytes': 'total_bytes',
                            'total_packets': 'total_packets',
                            'last_update_timestamp': 'last_update_timestamp',
                            'transport_node_id': 'transport_node_id',
                            }

    def __init__(self,
                 active_sessions=None,
                 total_bytes=None,
                 total_packets=None,
                 last_update_timestamp=None,
                 transport_node_id=None,
                ):
        """
        :type  active_sessions: :class:`long` or ``None``
        :param active_sessions: The number of active sessions format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  total_bytes: :class:`long` or ``None``
        :param total_bytes: The number of bytes format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  total_packets: :class:`long` or ``None``
        :param total_packets: The number of packets format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_update_timestamp: :class:`long` or ``None``
        :param last_update_timestamp: Timestamp when the data was last updated; unset if data source has
            never updated the data. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  transport_node_id: :class:`str` or ``None``
        :param transport_node_id: Id for the transport node
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.active_sessions = active_sessions
        self.total_bytes = total_bytes
        self.total_packets = total_packets
        self.last_update_timestamp = last_update_timestamp
        self.transport_node_id = transport_node_id
        VapiStruct.__init__(self)


NatStatisticsPerTransportNode._set_binding_type(type.StructType(
    'com.vmware.nsx.model.nat_statistics_per_transport_node', {
        'active_sessions': type.OptionalType(type.IntegerType()),
        'total_bytes': type.OptionalType(type.IntegerType()),
        'total_packets': type.OptionalType(type.IntegerType()),
        'last_update_timestamp': type.OptionalType(type.IntegerType()),
        'transport_node_id': type.OptionalType(type.StringType()),
    },
    NatStatisticsPerTransportNode,
    False,
    None))



class NdpHeader(VapiStruct):
    """
    Neighbor discovery protocol header

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    MSG_TYPE_SOLICITATION = "NEIGHBOR_SOLICITATION"
    """


    """
    MSG_TYPE_ADVERTISEMENT = "NEIGHBOR_ADVERTISEMENT"
    """


    """



    _canonical_to_pep_names = {
                            'dst_ip': 'dst_ip',
                            'msg_type': 'msg_type',
                            }

    def __init__(self,
                 dst_ip=None,
                 msg_type=None,
                ):
        """
        :type  dst_ip: :class:`str` or ``None``
        :param dst_ip: The IP address of the destination of the solicitation. It MUST NOT
            be a multicast address. format: ipv6
        :type  msg_type: :class:`str` or ``None``
        :param msg_type: Possible values are: 
            
            * :attr:`NdpHeader.MSG_TYPE_SOLICITATION`
            * :attr:`NdpHeader.MSG_TYPE_ADVERTISEMENT`
            
            This field specifies the type of the Neighbor discover message
            being sent. NEIGHBOR_SOLICITATION - Neighbor Solicitation message
            to discover the link-layer address of an on-link IPv6 node or to
            confirm a previously determined link-layer address.
            NEIGHBOR_ADVERTISEMENT - Neighbor Advertisement message in response
            to a Neighbor Solicitation message.
        """
        self.dst_ip = dst_ip
        self.msg_type = msg_type
        VapiStruct.__init__(self)


NdpHeader._set_binding_type(type.StructType(
    'com.vmware.nsx.model.ndp_header', {
        'dst_ip': type.OptionalType(type.StringType()),
        'msg_type': type.OptionalType(type.StringType()),
    },
    NdpHeader,
    False,
    None))



class NeighborProperties(VapiStruct):
    """
    Neighbor properties

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'capabilities': 'capabilities',
                            'enabled_capabilities': 'enabled_capabilities',
                            'ifindex': 'ifindex',
                            'link_aggregation_capable': 'link_aggregation_capable',
                            'link_aggregation_port_id': 'link_aggregation_port_id',
                            'link_aggregation_status': 'link_aggregation_status',
                            'mac': 'mac',
                            'mgmt_addr': 'mgmt_addr',
                            'name': 'name',
                            'oid': 'oid',
                            'port_desc': 'port_desc',
                            'system_desc': 'system_desc',
                            'system_name': 'system_name',
                            'system_port_number': 'system_port_number',
                            }

    def __init__(self,
                 capabilities=None,
                 enabled_capabilities=None,
                 ifindex=None,
                 link_aggregation_capable=None,
                 link_aggregation_port_id=None,
                 link_aggregation_status=None,
                 mac=None,
                 mgmt_addr=None,
                 name=None,
                 oid=None,
                 port_desc=None,
                 system_desc=None,
                 system_name=None,
                 system_port_number=None,
                ):
        """
        :type  capabilities: :class:`str` or ``None``
        :param capabilities: Capabilities
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  enabled_capabilities: :class:`str` or ``None``
        :param enabled_capabilities: Enabled capabilities
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  ifindex: :class:`long` or ``None``
        :param ifindex: Interface index format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  link_aggregation_capable: :class:`bool` or ``None``
        :param link_aggregation_capable: Aggregation Capability
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  link_aggregation_port_id: :class:`str` or ``None``
        :param link_aggregation_port_id: Aggregation port id
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  link_aggregation_status: :class:`bool` or ``None``
        :param link_aggregation_status: True if currently in aggregation
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  mac: :class:`str` or ``None``
        :param mac: Interface MAC address
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  mgmt_addr: :class:`str` or ``None``
        :param mgmt_addr: Management address
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  name: :class:`str` or ``None``
        :param name: Interface name
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  oid: :class:`str` or ``None``
        :param oid: Object identifier
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  port_desc: :class:`str` or ``None``
        :param port_desc: Port description
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_desc: :class:`str` or ``None``
        :param system_desc: System description
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_name: :class:`str` or ``None``
        :param system_name: System name
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_port_number: :class:`long` or ``None``
        :param system_port_number: System port number format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.capabilities = capabilities
        self.enabled_capabilities = enabled_capabilities
        self.ifindex = ifindex
        self.link_aggregation_capable = link_aggregation_capable
        self.link_aggregation_port_id = link_aggregation_port_id
        self.link_aggregation_status = link_aggregation_status
        self.mac = mac
        self.mgmt_addr = mgmt_addr
        self.name = name
        self.oid = oid
        self.port_desc = port_desc
        self.system_desc = system_desc
        self.system_name = system_name
        self.system_port_number = system_port_number
        VapiStruct.__init__(self)


NeighborProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.neighbor_properties', {
        'capabilities': type.OptionalType(type.StringType()),
        'enabled_capabilities': type.OptionalType(type.StringType()),
        'ifindex': type.OptionalType(type.IntegerType()),
        'link_aggregation_capable': type.OptionalType(type.BooleanType()),
        'link_aggregation_port_id': type.OptionalType(type.StringType()),
        'link_aggregation_status': type.OptionalType(type.BooleanType()),
        'mac': type.OptionalType(type.StringType()),
        'mgmt_addr': type.OptionalType(type.StringType()),
        'name': type.OptionalType(type.StringType()),
        'oid': type.OptionalType(type.StringType()),
        'port_desc': type.OptionalType(type.StringType()),
        'system_desc': type.OptionalType(type.StringType()),
        'system_name': type.OptionalType(type.StringType()),
        'system_port_number': type.OptionalType(type.IntegerType()),
    },
    NeighborProperties,
    False,
    None))



class NetworkError(VapiStruct):
    """
    Network error related to container objects.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'error_code': 'error_code',
                            'error_message': 'error_message',
                            'spec': 'spec',
                            }

    def __init__(self,
                 error_code=None,
                 error_message=None,
                 spec=None,
                ):
        """
        :type  error_code: :class:`str` or ``None``
        :param error_code: Error code of network related error.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  error_message: :class:`str` or ``None``
        :param error_message: Detailed message of network related error.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  spec: :class:`str` or ``None``
        :param spec: Additional error information in json format.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.error_code = error_code
        self.error_message = error_message
        self.spec = spec
        VapiStruct.__init__(self)


NetworkError._set_binding_type(type.StructType(
    'com.vmware.nsx.model.network_error', {
        'error_code': type.OptionalType(type.StringType()),
        'error_message': type.OptionalType(type.StringType()),
        'spec': type.OptionalType(type.StringType()),
    },
    NetworkError,
    False,
    None))



class NextHopPrefixListsMapping(VapiStruct):
    """
    Next hop to prefix lists mapping.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'next_hop': 'next_hop',
                            'prefix_lists': 'prefix_lists',
                            }

    def __init__(self,
                 next_hop=None,
                 prefix_lists=None,
                ):
        """
        :type  next_hop: :class:`str` or ``None``
        :param next_hop: Next hop address.
        :type  prefix_lists: :class:`list` of :class:`str` or ``None``
        :param prefix_lists: Array of Prefix list UUIDs.
        """
        self.next_hop = next_hop
        self.prefix_lists = prefix_lists
        VapiStruct.__init__(self)


NextHopPrefixListsMapping._set_binding_type(type.StructType(
    'com.vmware.nsx.model.next_hop_prefix_lists_mapping', {
        'next_hop': type.OptionalType(type.StringType()),
        'prefix_lists': type.OptionalType(type.ListType(type.StringType())),
    },
    NextHopPrefixListsMapping,
    False,
    None))



class NicInfo(VapiStruct):
    """
    Information of a network interface present on the partner appliance that
    needs to be configured by the NSX Manager.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    IP_ALLOCATION_TYPE_STATIC = "STATIC"
    """


    """
    IP_ALLOCATION_TYPE_DHCP = "DHCP"
    """


    """
    IP_ALLOCATION_TYPE_NONE = "NONE"
    """


    """



    _canonical_to_pep_names = {
                            'gateway_address': 'gateway_address',
                            'ip_address': 'ip_address',
                            'ip_allocation_type': 'ip_allocation_type',
                            'ip_pool_id': 'ip_pool_id',
                            'network_id': 'network_id',
                            'nic_metadata': 'nic_metadata',
                            'subnet_mask': 'subnet_mask',
                            }

    def __init__(self,
                 gateway_address=None,
                 ip_address=None,
                 ip_allocation_type=None,
                 ip_pool_id=None,
                 network_id=None,
                 nic_metadata=None,
                 subnet_mask=None,
                ):
        """
        :type  gateway_address: :class:`str` or ``None``
        :param gateway_address: Gateway address associated with the NIC metadata.
        :type  ip_address: :class:`str` or ``None``
        :param ip_address: IP address associated with the NIC metadata. Required only when
            assigning IP statically for a deployment that is for a single VM
            instance.
        :type  ip_allocation_type: :class:`str` or ``None``
        :param ip_allocation_type: Possible values are: 
            
            * :attr:`NicInfo.IP_ALLOCATION_TYPE_STATIC`
            * :attr:`NicInfo.IP_ALLOCATION_TYPE_DHCP`
            * :attr:`NicInfo.IP_ALLOCATION_TYPE_NONE`
            
            IP allocation type with values STATIC, DHCP, or NONE indicating
            that IP address is not required.
        :type  ip_pool_id: :class:`str` or ``None``
        :param ip_pool_id: If the nic should get IP using a static IP pool then IP pool id
            should be provided here.
        :type  network_id: :class:`str` or ``None``
        :param network_id: Network Id associated with the NIC metadata. It can be a moref, or
            a logical switch ID. If it is to be taken from 'Agent VM Settings',
            then it should be empty.
        :type  nic_metadata: :class:`NicMetadata` or ``None``
        :param nic_metadata: NIC metadata information.
        :type  subnet_mask: :class:`str` or ``None``
        :param subnet_mask: Subnet mask associated with the NIC metadata.
        """
        self.gateway_address = gateway_address
        self.ip_address = ip_address
        self.ip_allocation_type = ip_allocation_type
        self.ip_pool_id = ip_pool_id
        self.network_id = network_id
        self.nic_metadata = nic_metadata
        self.subnet_mask = subnet_mask
        VapiStruct.__init__(self)


NicInfo._set_binding_type(type.StructType(
    'com.vmware.nsx.model.nic_info', {
        'gateway_address': type.OptionalType(type.StringType()),
        'ip_address': type.OptionalType(type.StringType()),
        'ip_allocation_type': type.OptionalType(type.StringType()),
        'ip_pool_id': type.OptionalType(type.StringType()),
        'network_id': type.OptionalType(type.StringType()),
        'nic_metadata': type.OptionalType(type.ReferenceType(__name__, 'NicMetadata')),
        'subnet_mask': type.OptionalType(type.StringType()),
    },
    NicInfo,
    False,
    None))



class NicMetadata(VapiStruct):
    """
    Information on the Network interfaces present on the partner appliance that
    needs to be configured by the NSX Manager.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    INTERFACE_TYPE_MANAGEMENT = "MANAGEMENT"
    """


    """
    INTERFACE_TYPE_DATA1 = "DATA1"
    """


    """
    INTERFACE_TYPE_DATA2 = "DATA2"
    """


    """
    INTERFACE_TYPE_HA1 = "HA1"
    """


    """
    INTERFACE_TYPE_HA2 = "HA2"
    """


    """
    INTERFACE_TYPE_CONTROL = "CONTROL"
    """


    """
    TRANSPORTS_L2_BRIDGE = "L2_BRIDGE"
    """


    """
    TRANSPORTS_L3_ROUTED = "L3_ROUTED"
    """


    """
    TRANSPORTS_NSH = "NSH"
    """


    """



    _canonical_to_pep_names = {
                            'interface_index': 'interface_index',
                            'interface_label': 'interface_label',
                            'interface_type': 'interface_type',
                            'transports': 'transports',
                            'user_configurable': 'user_configurable',
                            }

    def __init__(self,
                 interface_index=None,
                 interface_label=None,
                 interface_type=None,
                 transports=None,
                 user_configurable=None,
                ):
        """
        :type  interface_index: :class:`long` or ``None``
        :param interface_index: Network Interface index. format: int64
        :type  interface_label: :class:`str` or ``None``
        :param interface_label: Network Interface label.
        :type  interface_type: :class:`str` or ``None``
        :param interface_type: Possible values are: 
            
            * :attr:`NicMetadata.INTERFACE_TYPE_MANAGEMENT`
            * :attr:`NicMetadata.INTERFACE_TYPE_DATA1`
            * :attr:`NicMetadata.INTERFACE_TYPE_DATA2`
            * :attr:`NicMetadata.INTERFACE_TYPE_HA1`
            * :attr:`NicMetadata.INTERFACE_TYPE_HA2`
            * :attr:`NicMetadata.INTERFACE_TYPE_CONTROL`
            
            Interface that needs to be configured on the partner appliance. Ex.
            MANAGEMENT, DATA1, DATA2, HA1, HA2, CONTROL.
        :type  transports: :class:`list` of :class:`str` or ``None``
        :param transports: Possible values are: 
            
            * :attr:`NicMetadata.TRANSPORTS_L2_BRIDGE`
            * :attr:`NicMetadata.TRANSPORTS_L3_ROUTED`
            * :attr:`NicMetadata.TRANSPORTS_NSH`
            
            Transport Type of the service, which is the mechanism of
            redirecting the traffic to the the partner appliance. Transport
            type is required if Service caters to any functionality other than
            EPP. Here, the transports array specifies the kinds of transport
            where this particular NIC is user configurable. If nothing is
            specified, and the \"user_configurable\" flag is true, then user
            configuration will be allowed for all transports. If any transport
            is/are specified, then it will be considered as user configurable
            for the specified transports only.\"
        :type  user_configurable: :class:`bool` or ``None``
        :param user_configurable: Used to specify if the given interface needs configuration.
            Management nics will always need the configuration, for others it
            will be use case specific. For example, a DATA NIC may be user
            configurable if the appliance is deployed in certain mode, such as
            L3_ROUTED.
        """
        self.interface_index = interface_index
        self.interface_label = interface_label
        self.interface_type = interface_type
        self.transports = transports
        self.user_configurable = user_configurable
        VapiStruct.__init__(self)


NicMetadata._set_binding_type(type.StructType(
    'com.vmware.nsx.model.nic_metadata', {
        'interface_index': type.OptionalType(type.IntegerType()),
        'interface_label': type.OptionalType(type.StringType()),
        'interface_type': type.OptionalType(type.StringType()),
        'transports': type.OptionalType(type.ListType(type.StringType())),
        'user_configurable': type.OptionalType(type.BooleanType()),
    },
    NicMetadata,
    False,
    None))



class NiocProfile(VapiStruct):
    """
    This profile is created for Network I/O Control(NIOC).

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "NiocProfile"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'enabled': 'enabled',
                            'host_infra_traffic_res': 'host_infra_traffic_res',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'required_capabilities': 'required_capabilities',
                            }

    def __init__(self,
                 enabled=None,
                 host_infra_traffic_res=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='NiocProfile',
                 tags=None,
                 required_capabilities=None,
                ):
        """
        :type  enabled: :class:`bool` or ``None``
        :param enabled: The enabled property specifies the status of NIOC feature. When
            enabled is set to true, NIOC feature is turned on and the bandwidth
            allocations specified for the traffic resources are enforced. When
            enabled is set to false, NIOC feature is turned off and no
            bandwidth allocation is guaranteed. By default, enabled will be set
            to true.
        :type  host_infra_traffic_res: :class:`list` of :class:`ResourceAllocation` or ``None``
        :param host_infra_traffic_res: host_infra_traffic_res specifies bandwidth allocation for various
            traffic resources.
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            *
              :attr:`BaseHostSwitchProfile.RESOURCE_TYPE_UPLINKHOSTSWITCHPROFILE`
            * :attr:`BaseHostSwitchProfile.RESOURCE_TYPE_LLDPHOSTSWITCHPROFILE`
            * :attr:`BaseHostSwitchProfile.RESOURCE_TYPE_NIOCPROFILE`
            *
              :attr:`BaseHostSwitchProfile.RESOURCE_TYPE_EXTRACONFIGHOSTSWITCHPROFILE`
            
             Supported HostSwitch profiles.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  required_capabilities: :class:`list` of :class:`str` or ``None``
        :param required_capabilities: 
        """
        self.enabled = enabled
        self.host_infra_traffic_res = host_infra_traffic_res
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        self.required_capabilities = required_capabilities
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

NiocProfile._set_binding_type(type.StructType(
    'com.vmware.nsx.model.nioc_profile', {
        'enabled': type.OptionalType(type.BooleanType()),
        'host_infra_traffic_res': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceAllocation'))),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'required_capabilities': type.OptionalType(type.ListType(type.StringType())),
    },
    NiocProfile,
    False,
    None))



class Node(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "Node"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'discovered_ip_addresses': 'discovered_ip_addresses',
                            'external_id': 'external_id',
                            'fqdn': 'fqdn',
                            'ip_addresses': 'ip_addresses',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='Node',
                 tags=None,
                 discovered_ip_addresses=None,
                 external_id=None,
                 fqdn=None,
                 ip_addresses=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Fabric node type, for example 'HostNode', 'EdgeNode' or
            'PublicCloudGatewayNode'
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  discovered_ip_addresses: :class:`list` of :class:`str` or ``None``
        :param discovered_ip_addresses: Discovered IP Addresses of the fabric node, version 4 or 6 format:
            ip
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  external_id: :class:`str` or ``None``
        :param external_id: ID of the Node maintained on the Node and used to recognize the
            Node
        :type  fqdn: :class:`str` or ``None``
        :param fqdn: Fully qualified domain name of the fabric node
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  ip_addresses: :class:`list` of :class:`str` or ``None``
        :param ip_addresses: IP Addresses of the Node, version 4 or 6. This property is
            mandatory for all nodes except for automatic deployment of edge
            virtual machine node. For automatic deployment, the ip address from
            management_port_subnets property will be considered. format: ip
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        self.discovered_ip_addresses = discovered_ip_addresses
        self.external_id = external_id
        self.fqdn = fqdn
        self.ip_addresses = ip_addresses
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

Node._set_binding_type(type.StructType(
    'com.vmware.nsx.model.node', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'discovered_ip_addresses': type.OptionalType(type.ListType(type.StringType())),
        'external_id': type.OptionalType(type.StringType()),
        'fqdn': type.OptionalType(type.StringType()),
        'ip_addresses': type.OptionalType(type.ListType(type.StringType())),
    },
    Node,
    False,
    None))



class NodeAsyncReplicatorServiceProperties(VapiStruct):
    """
    Node service properties

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'service_name': 'service_name',
                            'service_properties': 'service_properties',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 service_name=None,
                 service_properties=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  service_name: :class:`str` or ``None``
        :param service_name: Service name
        :type  service_properties: :class:`LoggingServiceProperties` or ``None``
        :param service_properties: Service properties
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.service_name = service_name
        self.service_properties = service_properties
        VapiStruct.__init__(self)


NodeAsyncReplicatorServiceProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.node_async_replicator_service_properties', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'service_name': type.OptionalType(type.StringType()),
        'service_properties': type.OptionalType(type.ReferenceType(__name__, 'LoggingServiceProperties')),
    },
    NodeAsyncReplicatorServiceProperties,
    False,
    None))



class NodeAuthProviderVidmProperties(VapiStruct):
    """
    Node AAA provider vIDM properties

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'client_id': 'client_id',
                            'client_secret': 'client_secret',
                            'host_name': 'host_name',
                            'lb_enable': 'lb_enable',
                            'node_host_name': 'node_host_name',
                            'thumbprint': 'thumbprint',
                            'vidm_enable': 'vidm_enable',
                            }

    def __init__(self,
                 client_id=None,
                 client_secret=None,
                 host_name=None,
                 lb_enable=None,
                 node_host_name=None,
                 thumbprint=None,
                 vidm_enable=None,
                ):
        """
        :type  client_id: :class:`str` or ``None``
        :param client_id: vIDM client id
        :type  client_secret: :class:`str` or ``None``
        :param client_secret: vIDM client secret
        :type  host_name: :class:`str` or ``None``
        :param host_name: Fully Qualified Domain Name(FQDN) of vIDM
        :type  lb_enable: :class:`bool` or ``None``
        :param lb_enable: Load Balancer enable flag
        :type  node_host_name: :class:`str` or ``None``
        :param node_host_name: host name to use when creating the redirect URL for clients to
            follow after authenticating to vIDM
        :type  thumbprint: :class:`str` or ``None``
        :param thumbprint: Hexadecimal SHA256 hash of the vIDM server's X.509 certificate
        :type  vidm_enable: :class:`bool` or ``None``
        :param vidm_enable: vIDM enable flag
        """
        self.client_id = client_id
        self.client_secret = client_secret
        self.host_name = host_name
        self.lb_enable = lb_enable
        self.node_host_name = node_host_name
        self.thumbprint = thumbprint
        self.vidm_enable = vidm_enable
        VapiStruct.__init__(self)


NodeAuthProviderVidmProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.node_auth_provider_vidm_properties', {
        'client_id': type.OptionalType(type.StringType()),
        'client_secret': type.OptionalType(type.StringType()),
        'host_name': type.OptionalType(type.StringType()),
        'lb_enable': type.OptionalType(type.BooleanType()),
        'node_host_name': type.OptionalType(type.StringType()),
        'thumbprint': type.OptionalType(type.StringType()),
        'vidm_enable': type.OptionalType(type.BooleanType()),
    },
    NodeAuthProviderVidmProperties,
    False,
    None))



class NodeAuthProviderVidmStatus(VapiStruct):
    """
    Node AAA provider vIDM status

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'runtime_state': 'runtime_state',
                            'vidm_enable': 'vidm_enable',
                            }

    def __init__(self,
                 runtime_state=None,
                 vidm_enable=None,
                ):
        """
        :type  runtime_state: :class:`str` or ``None``
        :param runtime_state: AAA provider vIDM status
        :type  vidm_enable: :class:`bool` or ``None``
        :param vidm_enable: vIDM enable flag
        """
        self.runtime_state = runtime_state
        self.vidm_enable = vidm_enable
        VapiStruct.__init__(self)


NodeAuthProviderVidmStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.node_auth_provider_vidm_status', {
        'runtime_state': type.OptionalType(type.StringType()),
        'vidm_enable': type.OptionalType(type.BooleanType()),
    },
    NodeAuthProviderVidmStatus,
    False,
    None))



class NodeCapabilitiesResult(VapiStruct):
    """
    List of capabilities of a fabric node

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'capabilities': 'capabilities',
                            }

    def __init__(self,
                 capabilities=None,
                ):
        """
        :type  capabilities: :class:`list` of :class:`NodeCapability` or ``None``
        :param capabilities: Node capability results
        """
        self.capabilities = capabilities
        VapiStruct.__init__(self)


NodeCapabilitiesResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.node_capabilities_result', {
        'capabilities': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NodeCapability'))),
    },
    NodeCapabilitiesResult,
    False,
    None))



class NodeCapability(VapiStruct):
    """
    Capability of a fabric node

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'description': 'description',
                            'key': 'key',
                            'provider': 'provider',
                            'value': 'value',
                            'version': 'version',
                            }

    def __init__(self,
                 description=None,
                 key=None,
                 provider=None,
                 value=None,
                 version=None,
                ):
        """
        :type  description: :class:`str` or ``None``
        :param description: Description of this capability that can be displayed in UI
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  key: :class:`str` or ``None``
        :param key: String that identifies the base capability for all nodes
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  provider: :class:`str` or ``None``
        :param provider: Provider of this capability for the node
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  value: :class:`str` or ``None``
        :param value: Value of this capability
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  version: :class:`long` or ``None``
        :param version: Version of the capability format: int32
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.description = description
        self.key = key
        self.provider = provider
        self.value = value
        self.version = version
        VapiStruct.__init__(self)


NodeCapability._set_binding_type(type.StructType(
    'com.vmware.nsx.model.node_capability', {
        'description': type.OptionalType(type.StringType()),
        'key': type.OptionalType(type.StringType()),
        'provider': type.OptionalType(type.StringType()),
        'value': type.OptionalType(type.StringType()),
        'version': type.OptionalType(type.IntegerType()),
    },
    NodeCapability,
    False,
    None))



class NodeCertificateInfo(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    ENTITY_TYPE_HTTP = "HTTP"
    """


    """
    ENTITY_TYPE_DATASTORE = "DATASTORE"
    """


    """
    ENTITY_TYPE_MANAGER = "MANAGER"
    """


    """
    ENTITY_TYPE_POLICY = "POLICY"
    """


    """
    ENTITY_TYPE_CONTROLLER = "CONTROLLER"
    """


    """



    _canonical_to_pep_names = {
                            'certificate': 'certificate',
                            'certificate_sha256_thumbprint': 'certificate_sha256_thumbprint',
                            'entity_type': 'entity_type',
                            }

    def __init__(self,
                 certificate=None,
                 certificate_sha256_thumbprint=None,
                 entity_type=None,
                ):
        """
        :type  certificate: :class:`str` or ``None``
        :param certificate: Certificate content
        :type  certificate_sha256_thumbprint: :class:`str` or ``None``
        :param certificate_sha256_thumbprint: SHA256 of certificate
        :type  entity_type: :class:`str` or ``None``
        :param entity_type: Possible values are: 
            
            * :attr:`NodeCertificateInfo.ENTITY_TYPE_HTTP`
            * :attr:`NodeCertificateInfo.ENTITY_TYPE_DATASTORE`
            * :attr:`NodeCertificateInfo.ENTITY_TYPE_MANAGER`
            * :attr:`NodeCertificateInfo.ENTITY_TYPE_POLICY`
            * :attr:`NodeCertificateInfo.ENTITY_TYPE_CONTROLLER`
            
             Entity type of this certificate
        """
        self.certificate = certificate
        self.certificate_sha256_thumbprint = certificate_sha256_thumbprint
        self.entity_type = entity_type
        VapiStruct.__init__(self)


NodeCertificateInfo._set_binding_type(type.StructType(
    'com.vmware.nsx.model.node_certificate_info', {
        'certificate': type.OptionalType(type.StringType()),
        'certificate_sha256_thumbprint': type.OptionalType(type.StringType()),
        'entity_type': type.OptionalType(type.StringType()),
    },
    NodeCertificateInfo,
    False,
    None))



class NodeEntityInfo(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    ENTITY_TYPE_HTTP = "HTTP"
    """


    """
    ENTITY_TYPE_DATASTORE = "DATASTORE"
    """


    """
    ENTITY_TYPE_MANAGER = "MANAGER"
    """


    """
    ENTITY_TYPE_POLICY = "POLICY"
    """


    """
    ENTITY_TYPE_CONTROLLER = "CONTROLLER"
    """


    """



    _canonical_to_pep_names = {
                            'entity_type': 'entity_type',
                            'ip_address': 'ip_address',
                            'port': 'port',
                            }

    def __init__(self,
                 entity_type=None,
                 ip_address=None,
                 port=None,
                ):
        """
        :type  entity_type: :class:`str` or ``None``
        :param entity_type: Possible values are: 
            
            * :attr:`NodeEntityInfo.ENTITY_TYPE_HTTP`
            * :attr:`NodeEntityInfo.ENTITY_TYPE_DATASTORE`
            * :attr:`NodeEntityInfo.ENTITY_TYPE_MANAGER`
            * :attr:`NodeEntityInfo.ENTITY_TYPE_POLICY`
            * :attr:`NodeEntityInfo.ENTITY_TYPE_CONTROLLER`
            
             Entity type of this service endpoint
        :type  ip_address: :class:`str` or ``None``
        :param ip_address: IP address of service provider
        :type  port: :class:`long` or ``None``
        :param port: Port number of service provider format: int64
        """
        self.entity_type = entity_type
        self.ip_address = ip_address
        self.port = port
        VapiStruct.__init__(self)


NodeEntityInfo._set_binding_type(type.StructType(
    'com.vmware.nsx.model.node_entity_info', {
        'entity_type': type.OptionalType(type.StringType()),
        'ip_address': type.OptionalType(type.StringType()),
        'port': type.OptionalType(type.IntegerType()),
    },
    NodeEntityInfo,
    False,
    None))



class NodeFileSystemProperties(VapiStruct):
    """
    File system properties

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'file_system': 'file_system',
                            'mount': 'mount',
                            'total': 'total',
                            'type': 'type',
                            'used': 'used',
                            }

    def __init__(self,
                 file_system=None,
                 mount=None,
                 total=None,
                 type=None,
                 used=None,
                ):
        """
        :type  file_system: :class:`str` or ``None``
        :param file_system: File system id
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  mount: :class:`str` or ``None``
        :param mount: File system mount
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  total: :class:`long` or ``None``
        :param total: File system size in kilobytes format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  type: :class:`str` or ``None``
        :param type: File system type
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  used: :class:`long` or ``None``
        :param used: Amount of file system used in kilobytes format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.file_system = file_system
        self.mount = mount
        self.total = total
        self.type = type
        self.used = used
        VapiStruct.__init__(self)


NodeFileSystemProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.node_file_system_properties', {
        'file_system': type.OptionalType(type.StringType()),
        'mount': type.OptionalType(type.StringType()),
        'total': type.OptionalType(type.IntegerType()),
        'type': type.OptionalType(type.StringType()),
        'used': type.OptionalType(type.IntegerType()),
    },
    NodeFileSystemProperties,
    False,
    None))



class NodeHttpServiceProperties(VapiStruct):
    """
    Node HTTP service properties

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'service_name': 'service_name',
                            'service_properties': 'service_properties',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 service_name=None,
                 service_properties=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  service_name: :class:`str` or ``None``
        :param service_name: Service name
        :type  service_properties: :class:`HttpServiceProperties` or ``None``
        :param service_properties: HTTP Service properties
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.service_name = service_name
        self.service_properties = service_properties
        VapiStruct.__init__(self)


NodeHttpServiceProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.node_http_service_properties', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'service_name': type.OptionalType(type.StringType()),
        'service_properties': type.OptionalType(type.ReferenceType(__name__, 'HttpServiceProperties')),
    },
    NodeHttpServiceProperties,
    False,
    None))



class NodeIdServicesMap(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    SERVICE_TYPES_MGMT_CLUSTER = "MGMT_CLUSTER"
    """


    """
    SERVICE_TYPES_MGMT_PLANE = "MGMT_PLANE"
    """


    """
    SERVICE_TYPES_API = "API"
    """


    """
    SERVICE_TYPES_NOTIFICATION_COLLECTOR = "NOTIFICATION_COLLECTOR"
    """


    """
    SERVICE_TYPES_SYSLOG_SERVER = "SYSLOG_SERVER"
    """


    """
    SERVICE_TYPES_RSYSLOG_CLIENT = "RSYSLOG_CLIENT"
    """


    """
    SERVICE_TYPES_APH = "APH"
    """


    """
    SERVICE_TYPES_GLOBAL_MANAGER = "GLOBAL_MANAGER"
    """


    """
    SERVICE_TYPES_LOCAL_MANAGER = "LOCAL_MANAGER"
    """


    """
    SERVICE_TYPES_CLIENT_AUTH = "CLIENT_AUTH"
    """


    """



    _canonical_to_pep_names = {
                            'node_id': 'node_id',
                            'service_types': 'service_types',
                            }

    def __init__(self,
                 node_id=None,
                 service_types=None,
                ):
        """
        :type  node_id: :class:`str` or ``None``
        :param node_id: NodeId
        :type  service_types: :class:`list` of :class:`str` or ``None``
        :param service_types: Possible values are: 
            
            * :attr:`NodeIdServicesMap.SERVICE_TYPES_MGMT_CLUSTER`
            * :attr:`NodeIdServicesMap.SERVICE_TYPES_MGMT_PLANE`
            * :attr:`NodeIdServicesMap.SERVICE_TYPES_API`
            * :attr:`NodeIdServicesMap.SERVICE_TYPES_NOTIFICATION_COLLECTOR`
            * :attr:`NodeIdServicesMap.SERVICE_TYPES_SYSLOG_SERVER`
            * :attr:`NodeIdServicesMap.SERVICE_TYPES_RSYSLOG_CLIENT`
            * :attr:`NodeIdServicesMap.SERVICE_TYPES_APH`
            * :attr:`NodeIdServicesMap.SERVICE_TYPES_GLOBAL_MANAGER`
            * :attr:`NodeIdServicesMap.SERVICE_TYPES_LOCAL_MANAGER`
            * :attr:`NodeIdServicesMap.SERVICE_TYPES_CLIENT_AUTH`
            
             List of ServiceTypes.
        """
        self.node_id = node_id
        self.service_types = service_types
        VapiStruct.__init__(self)


NodeIdServicesMap._set_binding_type(type.StructType(
    'com.vmware.nsx.model.node_id_services_map', {
        'node_id': type.OptionalType(type.StringType()),
        'service_types': type.OptionalType(type.ListType(type.StringType())),
    },
    NodeIdServicesMap,
    False,
    None))



class NodeInfo(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'component_version': 'component_version',
                            'display_name': 'display_name',
                            'id': 'id',
                            'type': 'type',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 component_version=None,
                 display_name=None,
                 id=None,
                 type=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  component_version: :class:`str` or ``None``
        :param component_version: Component version of the node
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  display_name: :class:`str` or ``None``
        :param display_name: Name of the node
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  id: :class:`str` or ``None``
        :param id: Identifier of the node
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  type: :class:`str` or ``None``
        :param type: Node type
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.component_version = component_version
        self.display_name = display_name
        self.id = id
        self.type = type
        VapiStruct.__init__(self)


NodeInfo._set_binding_type(type.StructType(
    'com.vmware.nsx.model.node_info', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'component_version': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'type': type.OptionalType(type.StringType()),
    },
    NodeInfo,
    False,
    None))



class NodeInfoListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`NodeInfo` or ``None``
        :param results: Paged Collection of Nodes
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


NodeInfoListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.node_info_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NodeInfo'))),
    },
    NodeInfoListResult,
    False,
    None))



class NodeInstallUpgradeServiceProperties(VapiStruct):
    """
    Node install-upgrade service properties

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'service_name': 'service_name',
                            'service_properties': 'service_properties',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 service_name=None,
                 service_properties=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  service_name: :class:`str` or ``None``
        :param service_name: Service name
        :type  service_properties: :class:`InstallUpgradeServiceProperties` or ``None``
        :param service_properties: install-upgrade Service properties
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.service_name = service_name
        self.service_properties = service_properties
        VapiStruct.__init__(self)


NodeInstallUpgradeServiceProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.node_install_upgrade_service_properties', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'service_name': type.OptionalType(type.StringType()),
        'service_properties': type.OptionalType(type.ReferenceType(__name__, 'InstallUpgradeServiceProperties')),
    },
    NodeInstallUpgradeServiceProperties,
    False,
    None))



class NodeInterSiteStatistics(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'last_update_timestamp': 'last_update_timestamp',
                            'stats_per_site': 'stats_per_site',
                            'transport_node_id': 'transport_node_id',
                            }

    def __init__(self,
                 last_update_timestamp=None,
                 stats_per_site=None,
                 transport_node_id=None,
                ):
        """
        :type  last_update_timestamp: :class:`long` or ``None``
        :param last_update_timestamp: Timestamp when the remote tunnel port statistics was last updated.
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  stats_per_site: :class:`list` of :class:`RemoteTunnelStatisticsPerSite` or ``None``
        :param stats_per_site: Remote tunnel statistics per site.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  transport_node_id: :class:`str` or ``None``
        :param transport_node_id: Edge node id whose statistics is being reported.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.last_update_timestamp = last_update_timestamp
        self.stats_per_site = stats_per_site
        self.transport_node_id = transport_node_id
        VapiStruct.__init__(self)


NodeInterSiteStatistics._set_binding_type(type.StructType(
    'com.vmware.nsx.model.node_inter_site_statistics', {
        'last_update_timestamp': type.OptionalType(type.IntegerType()),
        'stats_per_site': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'RemoteTunnelStatisticsPerSite'))),
        'transport_node_id': type.OptionalType(type.StringType()),
    },
    NodeInterSiteStatistics,
    False,
    None))



class NodeInterfaceAlias(VapiStruct):
    """
    Node network interface alias

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    IP_CONFIGURATION_DHCP = "dhcp"
    """


    """
    IP_CONFIGURATION_STATIC = "static"
    """


    """
    IP_CONFIGURATION_NOT_CONFIGURED = "not configured"
    """


    """



    _canonical_to_pep_names = {
                            'broadcast_address': 'broadcast_address',
                            'ip_address': 'ip_address',
                            'ip_configuration': 'ip_configuration',
                            'netmask': 'netmask',
                            'physical_address': 'physical_address',
                            }

    def __init__(self,
                 broadcast_address=None,
                 ip_address=None,
                 ip_configuration=None,
                 netmask=None,
                 physical_address=None,
                ):
        """
        :type  broadcast_address: :class:`str` or ``None``
        :param broadcast_address: Interface broadcast address format: ip
        :type  ip_address: :class:`str` or ``None``
        :param ip_address: Interface IP address format: ip
        :type  ip_configuration: :class:`str` or ``None``
        :param ip_configuration: Possible values are: 
            
            * :attr:`NodeInterfaceAlias.IP_CONFIGURATION_DHCP`
            * :attr:`NodeInterfaceAlias.IP_CONFIGURATION_STATIC`
            * :attr:`NodeInterfaceAlias.IP_CONFIGURATION_NOT_CONFIGURED`
            
             Interface configuration
        :type  netmask: :class:`str` or ``None``
        :param netmask: Interface netmask
        :type  physical_address: :class:`str` or ``None``
        :param physical_address: Interface MAC address format: mac-address
        """
        self.broadcast_address = broadcast_address
        self.ip_address = ip_address
        self.ip_configuration = ip_configuration
        self.netmask = netmask
        self.physical_address = physical_address
        VapiStruct.__init__(self)


NodeInterfaceAlias._set_binding_type(type.StructType(
    'com.vmware.nsx.model.node_interface_alias', {
        'broadcast_address': type.OptionalType(type.StringType()),
        'ip_address': type.OptionalType(type.StringType()),
        'ip_configuration': type.OptionalType(type.StringType()),
        'netmask': type.OptionalType(type.StringType()),
        'physical_address': type.OptionalType(type.StringType()),
    },
    NodeInterfaceAlias,
    False,
    None))



class NodeInterfaceProperties(VapiStruct):
    """
    Node network interface properties

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    ADMIN_STATUS_UP = "UP"
    """


    """
    ADMIN_STATUS_DOWN = "DOWN"
    """


    """
    CONNECTED_SWITCH_TYPE_VSS = "VSS"
    """


    """
    CONNECTED_SWITCH_TYPE_DVS = "DVS"
    """


    """
    CONNECTED_SWITCH_TYPE_N_VDS = "N-VDS"
    """


    """
    INTERFACE_TYPE_PHYSICAL = "PHYSICAL"
    """


    """
    INTERFACE_TYPE_VIRTUAL = "VIRTUAL"
    """


    """
    LINK_STATUS_UP = "UP"
    """


    """
    LINK_STATUS_DOWN = "DOWN"
    """


    """
    SOURCE_REALTIME = "realtime"
    """


    """
    SOURCE_CACHED = "cached"
    """


    """



    _canonical_to_pep_names = {
                            'admin_status': 'admin_status',
                            'backing_nsx_managed': 'backing_nsx_managed',
                            'connected_switch': 'connected_switch',
                            'connected_switch_type': 'connected_switch_type',
                            'device': 'device',
                            'driver': 'driver',
                            'ens_capable': 'ens_capable',
                            'ens_enabled': 'ens_enabled',
                            'ens_interrupt_capable': 'ens_interrupt_capable',
                            'ens_interrupt_enabled': 'ens_interrupt_enabled',
                            'host_managed': 'host_managed',
                            'interface_alias': 'interface_alias',
                            'interface_id': 'interface_id',
                            'interface_type': 'interface_type',
                            'key': 'key',
                            'link_status': 'link_status',
                            'lport_attachment_id': 'lport_attachment_id',
                            'mtu': 'mtu',
                            'pci': 'pci',
                            'source': 'source',
                            }

    def __init__(self,
                 admin_status=None,
                 backing_nsx_managed=None,
                 connected_switch=None,
                 connected_switch_type=None,
                 device=None,
                 driver=None,
                 ens_capable=None,
                 ens_enabled=None,
                 ens_interrupt_capable=None,
                 ens_interrupt_enabled=None,
                 host_managed=None,
                 interface_alias=None,
                 interface_id=None,
                 interface_type=None,
                 key=None,
                 link_status=None,
                 lport_attachment_id=None,
                 mtu=None,
                 pci=None,
                 source=None,
                ):
        """
        :type  admin_status: :class:`str` or ``None``
        :param admin_status: Possible values are: 
            
            * :attr:`NodeInterfaceProperties.ADMIN_STATUS_UP`
            * :attr:`NodeInterfaceProperties.ADMIN_STATUS_DOWN`
            
             Interface administration status
        :type  backing_nsx_managed: :class:`bool` or ``None``
        :param backing_nsx_managed: Indicates whether backing of VIRTUAL network interface is managed
            by NSX
        :type  connected_switch: :class:`str` or ``None``
        :param connected_switch: Connected switch
        :type  connected_switch_type: :class:`str` or ``None``
        :param connected_switch_type: Possible values are: 
            
            * :attr:`NodeInterfaceProperties.CONNECTED_SWITCH_TYPE_VSS`
            * :attr:`NodeInterfaceProperties.CONNECTED_SWITCH_TYPE_DVS`
            * :attr:`NodeInterfaceProperties.CONNECTED_SWITCH_TYPE_N_VDS`
            
             Type of switch associated with the interface.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  device: :class:`str` or ``None``
        :param device: Device name.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  driver: :class:`str` or ``None``
        :param driver: Driver name.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  ens_capable: :class:`bool` or ``None``
        :param ens_capable: Interface capability for Enhanced Networking Stack
        :type  ens_enabled: :class:`bool` or ``None``
        :param ens_enabled: Indicates whether interface is enabled for Enhanced Networking
            Stack
        :type  ens_interrupt_capable: :class:`bool` or ``None``
        :param ens_interrupt_capable: This boolean property describes if network interface is capable for
            Enhanced Networking Stack interrupt
        :type  ens_interrupt_enabled: :class:`bool` or ``None``
        :param ens_interrupt_enabled: This boolean property describes if network interface is enabled for
            Enhanced Networking Stack interrupt
        :type  host_managed: :class:`bool` or ``None``
        :param host_managed: Indicates whether interface is managed by the host
        :type  interface_alias: :class:`list` of :class:`NodeInterfaceAlias` or ``None``
        :param interface_alias: IP Alias
        :type  interface_id: :class:`str` or ``None``
        :param interface_id: Interface ID
        :type  interface_type: :class:`str` or ``None``
        :param interface_type: Possible values are: 
            
            * :attr:`NodeInterfaceProperties.INTERFACE_TYPE_PHYSICAL`
            * :attr:`NodeInterfaceProperties.INTERFACE_TYPE_VIRTUAL`
            
             Interface Type
        :type  key: :class:`str` or ``None``
        :param key: Device key.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  link_status: :class:`str` or ``None``
        :param link_status: Possible values are: 
            
            * :attr:`NodeInterfaceProperties.LINK_STATUS_UP`
            * :attr:`NodeInterfaceProperties.LINK_STATUS_DOWN`
            
             Interface administration status
        :type  lport_attachment_id: :class:`str` or ``None``
        :param lport_attachment_id: LPort Attachment Id assigned to VIRTUAL network interface of a node
        :type  mtu: :class:`long` or ``None``
        :param mtu: Interface MTU format: int64
        :type  pci: :class:`str` or ``None``
        :param pci: PCI device.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  source: :class:`str` or ``None``
        :param source: Possible values are: 
            
            * :attr:`NodeInterfaceProperties.SOURCE_REALTIME`
            * :attr:`NodeInterfaceProperties.SOURCE_CACHED`
            
             Source of status data
        """
        self.admin_status = admin_status
        self.backing_nsx_managed = backing_nsx_managed
        self.connected_switch = connected_switch
        self.connected_switch_type = connected_switch_type
        self.device = device
        self.driver = driver
        self.ens_capable = ens_capable
        self.ens_enabled = ens_enabled
        self.ens_interrupt_capable = ens_interrupt_capable
        self.ens_interrupt_enabled = ens_interrupt_enabled
        self.host_managed = host_managed
        self.interface_alias = interface_alias
        self.interface_id = interface_id
        self.interface_type = interface_type
        self.key = key
        self.link_status = link_status
        self.lport_attachment_id = lport_attachment_id
        self.mtu = mtu
        self.pci = pci
        self.source = source
        VapiStruct.__init__(self)


NodeInterfaceProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.node_interface_properties', {
        'admin_status': type.OptionalType(type.StringType()),
        'backing_nsx_managed': type.OptionalType(type.BooleanType()),
        'connected_switch': type.OptionalType(type.StringType()),
        'connected_switch_type': type.OptionalType(type.StringType()),
        'device': type.OptionalType(type.StringType()),
        'driver': type.OptionalType(type.StringType()),
        'ens_capable': type.OptionalType(type.BooleanType()),
        'ens_enabled': type.OptionalType(type.BooleanType()),
        'ens_interrupt_capable': type.OptionalType(type.BooleanType()),
        'ens_interrupt_enabled': type.OptionalType(type.BooleanType()),
        'host_managed': type.OptionalType(type.BooleanType()),
        'interface_alias': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NodeInterfaceAlias'))),
        'interface_id': type.OptionalType(type.StringType()),
        'interface_type': type.OptionalType(type.StringType()),
        'key': type.OptionalType(type.StringType()),
        'link_status': type.OptionalType(type.StringType()),
        'lport_attachment_id': type.OptionalType(type.StringType()),
        'mtu': type.OptionalType(type.IntegerType()),
        'pci': type.OptionalType(type.StringType()),
        'source': type.OptionalType(type.StringType()),
    },
    NodeInterfaceProperties,
    False,
    None))



class NodeInterfacePropertiesListResult(VapiStruct):
    """
    Node network interface properties list results

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`NodeInterfaceProperties` or ``None``
        :param results: Node interface property results
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


NodeInterfacePropertiesListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.node_interface_properties_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NodeInterfaceProperties'))),
    },
    NodeInterfacePropertiesListResult,
    False,
    None))



class NodeInterfaceStatisticsProperties(VapiStruct):
    """
    Node network interface statistic properties

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    SOURCE_REALTIME = "realtime"
    """


    """
    SOURCE_CACHED = "cached"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'interface_id': 'interface_id',
                            'rx_bytes': 'rx_bytes',
                            'rx_dropped': 'rx_dropped',
                            'rx_errors': 'rx_errors',
                            'rx_frame': 'rx_frame',
                            'rx_packets': 'rx_packets',
                            'source': 'source',
                            'tx_bytes': 'tx_bytes',
                            'tx_carrier': 'tx_carrier',
                            'tx_colls': 'tx_colls',
                            'tx_dropped': 'tx_dropped',
                            'tx_errors': 'tx_errors',
                            'tx_packets': 'tx_packets',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 interface_id=None,
                 rx_bytes=None,
                 rx_dropped=None,
                 rx_errors=None,
                 rx_frame=None,
                 rx_packets=None,
                 source=None,
                 tx_bytes=None,
                 tx_carrier=None,
                 tx_colls=None,
                 tx_dropped=None,
                 tx_errors=None,
                 tx_packets=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  interface_id: :class:`str` or ``None``
        :param interface_id: Interface ID
        :type  rx_bytes: :class:`long` or ``None``
        :param rx_bytes: Number of bytes received format: int64
        :type  rx_dropped: :class:`long` or ``None``
        :param rx_dropped: Number of packets dropped format: int64
        :type  rx_errors: :class:`long` or ``None``
        :param rx_errors: Number of receive errors format: int64
        :type  rx_frame: :class:`long` or ``None``
        :param rx_frame: Number of framing errors format: int64
        :type  rx_packets: :class:`long` or ``None``
        :param rx_packets: Number of packets received format: int64
        :type  source: :class:`str` or ``None``
        :param source: Possible values are: 
            
            * :attr:`NodeInterfaceStatisticsProperties.SOURCE_REALTIME`
            * :attr:`NodeInterfaceStatisticsProperties.SOURCE_CACHED`
            
             Source of status data.
        :type  tx_bytes: :class:`long` or ``None``
        :param tx_bytes: Number of bytes transmitted format: int64
        :type  tx_carrier: :class:`long` or ``None``
        :param tx_carrier: Number of carrier losses detected format: int64
        :type  tx_colls: :class:`long` or ``None``
        :param tx_colls: Number of collisions detected format: int64
        :type  tx_dropped: :class:`long` or ``None``
        :param tx_dropped: Number of packets dropped format: int64
        :type  tx_errors: :class:`long` or ``None``
        :param tx_errors: Number of transmit errors format: int64
        :type  tx_packets: :class:`long` or ``None``
        :param tx_packets: Number of packets transmitted format: int64
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.interface_id = interface_id
        self.rx_bytes = rx_bytes
        self.rx_dropped = rx_dropped
        self.rx_errors = rx_errors
        self.rx_frame = rx_frame
        self.rx_packets = rx_packets
        self.source = source
        self.tx_bytes = tx_bytes
        self.tx_carrier = tx_carrier
        self.tx_colls = tx_colls
        self.tx_dropped = tx_dropped
        self.tx_errors = tx_errors
        self.tx_packets = tx_packets
        VapiStruct.__init__(self)


NodeInterfaceStatisticsProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.node_interface_statistics_properties', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'interface_id': type.OptionalType(type.StringType()),
        'rx_bytes': type.OptionalType(type.IntegerType()),
        'rx_dropped': type.OptionalType(type.IntegerType()),
        'rx_errors': type.OptionalType(type.IntegerType()),
        'rx_frame': type.OptionalType(type.IntegerType()),
        'rx_packets': type.OptionalType(type.IntegerType()),
        'source': type.OptionalType(type.StringType()),
        'tx_bytes': type.OptionalType(type.IntegerType()),
        'tx_carrier': type.OptionalType(type.IntegerType()),
        'tx_colls': type.OptionalType(type.IntegerType()),
        'tx_dropped': type.OptionalType(type.IntegerType()),
        'tx_errors': type.OptionalType(type.IntegerType()),
        'tx_packets': type.OptionalType(type.IntegerType()),
    },
    NodeInterfaceStatisticsProperties,
    False,
    None))



class NodeListResult(VapiStruct):
    """
    Node list result

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param results: Node list results
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in :class:`Node`.
            When methods return a value of this class as a return value, the
            attribute will contain all the attributes defined in :class:`Node`.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


NodeListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.node_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'Node')]))),
    },
    NodeListResult,
    False,
    None))



class NodeLogProperties(VapiStruct):
    """
    Node log properties

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'last_modified_time': 'last_modified_time',
                            'log_name': 'log_name',
                            'log_size': 'log_size',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 last_modified_time=None,
                 log_name=None,
                 log_size=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Last modified time expressed in milliseconds since epoch format:
            int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  log_name: :class:`str` or ``None``
        :param log_name: Name of log file
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  log_size: :class:`long` or ``None``
        :param log_size: Size of log file in bytes format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.last_modified_time = last_modified_time
        self.log_name = log_name
        self.log_size = log_size
        VapiStruct.__init__(self)


NodeLogProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.node_log_properties', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'last_modified_time': type.OptionalType(type.IntegerType()),
        'log_name': type.OptionalType(type.StringType()),
        'log_size': type.OptionalType(type.IntegerType()),
    },
    NodeLogProperties,
    False,
    None))



class NodeLogPropertiesListResult(VapiStruct):
    """
    Node log property query results

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`NodeLogProperties` or ``None``
        :param results: Node log property results
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


NodeLogPropertiesListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.node_log_properties_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NodeLogProperties'))),
    },
    NodeLogPropertiesListResult,
    False,
    None))



class NodeMessagingClientInfo(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    ENTITY_TYPE_HTTP = "HTTP"
    """


    """
    ENTITY_TYPE_DATASTORE = "DATASTORE"
    """


    """
    ENTITY_TYPE_MANAGER = "MANAGER"
    """


    """
    ENTITY_TYPE_POLICY = "POLICY"
    """


    """
    ENTITY_TYPE_CONTROLLER = "CONTROLLER"
    """


    """



    _canonical_to_pep_names = {
                            'clients': 'clients',
                            'entity_type': 'entity_type',
                            }

    def __init__(self,
                 clients=None,
                 entity_type=None,
                ):
        """
        :type  clients: :class:`list` of :class:`MessagingClientInfo` or ``None``
        :param clients: A list of messaging clients owned by this entity
        :type  entity_type: :class:`str` or ``None``
        :param entity_type: Possible values are: 
            
            * :attr:`NodeMessagingClientInfo.ENTITY_TYPE_HTTP`
            * :attr:`NodeMessagingClientInfo.ENTITY_TYPE_DATASTORE`
            * :attr:`NodeMessagingClientInfo.ENTITY_TYPE_MANAGER`
            * :attr:`NodeMessagingClientInfo.ENTITY_TYPE_POLICY`
            * :attr:`NodeMessagingClientInfo.ENTITY_TYPE_CONTROLLER`
            
             Entity type of this messaging client
        """
        self.clients = clients
        self.entity_type = entity_type
        VapiStruct.__init__(self)


NodeMessagingClientInfo._set_binding_type(type.StructType(
    'com.vmware.nsx.model.node_messaging_client_info', {
        'clients': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'MessagingClientInfo'))),
        'entity_type': type.OptionalType(type.StringType()),
    },
    NodeMessagingClientInfo,
    False,
    None))



class NodeMode(VapiStruct):
    """
    Possible values of a mode in a \"/config/nsx_appliance_mode\" file

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    MODE_ID_ON_PREM = "ON_PREM"
    """


    """
    MODE_ID_SERVICE = "SERVICE"
    """


    """
    MODE_ID_VMC = "VMC"
    """


    """
    MODE_ID_VMC_LOCAL = "VMC_LOCAL"
    """


    """



    _canonical_to_pep_names = {
                            'mode_id': 'mode_id',
                            }

    def __init__(self,
                 mode_id=None,
                ):
        """
        :type  mode_id: :class:`str` or ``None``
        :param mode_id: Possible values are: 
            
            * :attr:`NodeMode.MODE_ID_ON_PREM`
            * :attr:`NodeMode.MODE_ID_SERVICE`
            * :attr:`NodeMode.MODE_ID_VMC`
            * :attr:`NodeMode.MODE_ID_VMC_LOCAL`
            
             Possible enum values in a \"/config/nsx_appliance_mode\" file
        """
        self.mode_id = mode_id
        VapiStruct.__init__(self)


NodeMode._set_binding_type(type.StructType(
    'com.vmware.nsx.model.node_mode', {
        'mode_id': type.OptionalType(type.StringType()),
    },
    NodeMode,
    False,
    None))



class NodeNameServersProperties(VapiStruct):
    """
    Node network name servers properties

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'name_servers': 'name_servers',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 name_servers=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  name_servers: :class:`list` of :class:`str` or ``None``
        :param name_servers: Name servers
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.name_servers = name_servers
        VapiStruct.__init__(self)


NodeNameServersProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.node_name_servers_properties', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'name_servers': type.OptionalType(type.ListType(type.StringType())),
    },
    NodeNameServersProperties,
    False,
    None))



class NodeNetworkInterfaceProperties(VapiStruct):
    """
    Node network interface properties

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    ADMIN_STATUS_UP = "up"
    """


    """
    ADMIN_STATUS_DOWN = "down"
    """


    """
    BOND_MODE_ACTIVE_BACKUP = "ACTIVE_BACKUP"
    """


    """
    BOND_MODE_802_3AD = "802_3AD"
    """


    """
    BOND_MODE_ROUND_ROBIN = "ROUND_ROBIN"
    """


    """
    BOND_MODE_BROADCAST = "BROADCAST"
    """


    """
    BOND_MODE_XOR = "XOR"
    """


    """
    BOND_MODE_TLB = "TLB"
    """


    """
    BOND_MODE_ALB = "ALB"
    """


    """
    IP_CONFIGURATION_DHCP = "dhcp"
    """


    """
    IP_CONFIGURATION_STATIC = "static"
    """


    """
    IP_CONFIGURATION_NOT_CONFIGURED = "not configured"
    """


    """
    LINK_STATUS_UP = "up"
    """


    """
    LINK_STATUS_DOWN = "down"
    """


    """
    PLANE_MGMT = "mgmt"
    """


    """
    PLANE_DEBUG = "debug"
    """


    """
    PLANE_NONE = "none"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'admin_status': 'admin_status',
                            'bond_mode': 'bond_mode',
                            'bond_primary': 'bond_primary',
                            'bond_slaves': 'bond_slaves',
                            'broadcast_address': 'broadcast_address',
                            'default_gateway': 'default_gateway',
                            'interface_id': 'interface_id',
                            'ip_addresses': 'ip_addresses',
                            'ip_configuration': 'ip_configuration',
                            'is_kni': 'is_kni',
                            'link_status': 'link_status',
                            'mtu': 'mtu',
                            'physical_address': 'physical_address',
                            'plane': 'plane',
                            'vlan': 'vlan',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 admin_status=None,
                 bond_mode=None,
                 bond_primary=None,
                 bond_slaves=None,
                 broadcast_address=None,
                 default_gateway=None,
                 interface_id=None,
                 ip_addresses=None,
                 ip_configuration=None,
                 is_kni=None,
                 link_status=None,
                 mtu=None,
                 physical_address=None,
                 plane=None,
                 vlan=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  admin_status: :class:`str` or ``None``
        :param admin_status: Possible values are: 
            
            * :attr:`NodeNetworkInterfaceProperties.ADMIN_STATUS_UP`
            * :attr:`NodeNetworkInterfaceProperties.ADMIN_STATUS_DOWN`
            
             Interface administration status
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  bond_mode: :class:`str` or ``None``
        :param bond_mode: Possible values are: 
            
            * :attr:`NodeNetworkInterfaceProperties.BOND_MODE_ACTIVE_BACKUP`
            * :attr:`NodeNetworkInterfaceProperties.BOND_MODE__802_3AD`
            * :attr:`NodeNetworkInterfaceProperties.BOND_MODE_ROUND_ROBIN`
            * :attr:`NodeNetworkInterfaceProperties.BOND_MODE_BROADCAST`
            * :attr:`NodeNetworkInterfaceProperties.BOND_MODE_XOR`
            * :attr:`NodeNetworkInterfaceProperties.BOND_MODE_TLB`
            * :attr:`NodeNetworkInterfaceProperties.BOND_MODE_ALB`
            
             Bond mode
        :type  bond_primary: :class:`str` or ``None``
        :param bond_primary: Bond's primary device name in active-backup bond mode
        :type  bond_slaves: :class:`list` of :class:`str` or ``None``
        :param bond_slaves: Bond's slave devices
        :type  broadcast_address: :class:`str` or ``None``
        :param broadcast_address: Interface broadcast address
        :type  default_gateway: :class:`str` or ``None``
        :param default_gateway: Interface's default gateway
        :type  interface_id: :class:`str` or ``None``
        :param interface_id: Interface ID
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  ip_addresses: :class:`list` of :class:`IPv4AddressProperties` or ``None``
        :param ip_addresses: Interface IP addresses
        :type  ip_configuration: :class:`str` or ``None``
        :param ip_configuration: Possible values are: 
            
            * :attr:`NodeNetworkInterfaceProperties.IP_CONFIGURATION_DHCP`
            * :attr:`NodeNetworkInterfaceProperties.IP_CONFIGURATION_STATIC`
            *
              :attr:`NodeNetworkInterfaceProperties.IP_CONFIGURATION_NOT_CONFIGURED`
            
             Interface configuration
        :type  is_kni: :class:`bool` or ``None``
        :param is_kni: Interface is a KNI
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  link_status: :class:`str` or ``None``
        :param link_status: Possible values are: 
            
            * :attr:`NodeNetworkInterfaceProperties.LINK_STATUS_UP`
            * :attr:`NodeNetworkInterfaceProperties.LINK_STATUS_DOWN`
            
             Interface administration status
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  mtu: :class:`long` or ``None``
        :param mtu: Interface MTU format: int64
        :type  physical_address: :class:`str` or ``None``
        :param physical_address: Interface MAC address
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  plane: :class:`str` or ``None``
        :param plane: Possible values are: 
            
            * :attr:`NodeNetworkInterfaceProperties.PLANE_MGMT`
            * :attr:`NodeNetworkInterfaceProperties.PLANE_DEBUG`
            * :attr:`NodeNetworkInterfaceProperties.PLANE_NONE`
            
             Interface plane
        :type  vlan: :class:`long` or ``None``
        :param vlan: VLAN Id format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.admin_status = admin_status
        self.bond_mode = bond_mode
        self.bond_primary = bond_primary
        self.bond_slaves = bond_slaves
        self.broadcast_address = broadcast_address
        self.default_gateway = default_gateway
        self.interface_id = interface_id
        self.ip_addresses = ip_addresses
        self.ip_configuration = ip_configuration
        self.is_kni = is_kni
        self.link_status = link_status
        self.mtu = mtu
        self.physical_address = physical_address
        self.plane = plane
        self.vlan = vlan
        VapiStruct.__init__(self)


NodeNetworkInterfaceProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.node_network_interface_properties', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'admin_status': type.OptionalType(type.StringType()),
        'bond_mode': type.OptionalType(type.StringType()),
        'bond_primary': type.OptionalType(type.StringType()),
        'bond_slaves': type.OptionalType(type.ListType(type.StringType())),
        'broadcast_address': type.OptionalType(type.StringType()),
        'default_gateway': type.OptionalType(type.StringType()),
        'interface_id': type.OptionalType(type.StringType()),
        'ip_addresses': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IPv4AddressProperties'))),
        'ip_configuration': type.OptionalType(type.StringType()),
        'is_kni': type.OptionalType(type.BooleanType()),
        'link_status': type.OptionalType(type.StringType()),
        'mtu': type.OptionalType(type.IntegerType()),
        'physical_address': type.OptionalType(type.StringType()),
        'plane': type.OptionalType(type.StringType()),
        'vlan': type.OptionalType(type.IntegerType()),
    },
    NodeNetworkInterfaceProperties,
    False,
    None))



class NodeNetworkInterfacePropertiesListResult(VapiStruct):
    """
    Node network interface properties list results

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`NodeNetworkInterfaceProperties` or ``None``
        :param results: Node network interface property results
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


NodeNetworkInterfacePropertiesListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.node_network_interface_properties_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NodeNetworkInterfaceProperties'))),
    },
    NodeNetworkInterfacePropertiesListResult,
    False,
    None))



class NodeNetworkProperties(VapiStruct):
    """
    Network configuration properties

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        VapiStruct.__init__(self)


NodeNetworkProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.node_network_properties', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
    },
    NodeNetworkProperties,
    False,
    None))



class NodeNtpServiceProperties(VapiStruct):
    """
    Node NTP service properties

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'service_name': 'service_name',
                            'service_properties': 'service_properties',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 service_name=None,
                 service_properties=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  service_name: :class:`str` or ``None``
        :param service_name: Service name
        :type  service_properties: :class:`NtpServiceProperties` or ``None``
        :param service_properties: NTP Service properties
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.service_name = service_name
        self.service_properties = service_properties
        VapiStruct.__init__(self)


NodeNtpServiceProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.node_ntp_service_properties', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'service_name': type.OptionalType(type.StringType()),
        'service_properties': type.OptionalType(type.ReferenceType(__name__, 'NtpServiceProperties')),
    },
    NodeNtpServiceProperties,
    False,
    None))



class NodePolicyServiceProperties(VapiStruct):
    """
    Node service properties

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'service_name': 'service_name',
                            'service_properties': 'service_properties',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 service_name=None,
                 service_properties=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  service_name: :class:`str` or ``None``
        :param service_name: Service name
        :type  service_properties: :class:`LoggingServiceProperties` or ``None``
        :param service_properties: Service properties
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.service_name = service_name
        self.service_properties = service_properties
        VapiStruct.__init__(self)


NodePolicyServiceProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.node_policy_service_properties', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'service_name': type.OptionalType(type.StringType()),
        'service_properties': type.OptionalType(type.ReferenceType(__name__, 'LoggingServiceProperties')),
    },
    NodePolicyServiceProperties,
    False,
    None))



class NodeProcessProperties(VapiStruct):
    """
    Node process properties

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cpu_time': 'cpu_time',
                            'mem_resident': 'mem_resident',
                            'mem_used': 'mem_used',
                            'pid': 'pid',
                            'ppid': 'ppid',
                            'process_name': 'process_name',
                            'start_time': 'start_time',
                            'uptime': 'uptime',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cpu_time=None,
                 mem_resident=None,
                 mem_used=None,
                 pid=None,
                 ppid=None,
                 process_name=None,
                 start_time=None,
                 uptime=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cpu_time: :class:`long` or ``None``
        :param cpu_time: CPU time (user and system) consumed by process in milliseconds
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  mem_resident: :class:`long` or ``None``
        :param mem_resident: Resident set size of process in bytes format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  mem_used: :class:`long` or ``None``
        :param mem_used: Virtual memory used by process in bytes format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  pid: :class:`long` or ``None``
        :param pid: Process id format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  ppid: :class:`long` or ``None``
        :param ppid: Parent process id format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  process_name: :class:`str` or ``None``
        :param process_name: Process name
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  start_time: :class:`long` or ``None``
        :param start_time: Process start time expressed in milliseconds since epoch format:
            int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  uptime: :class:`long` or ``None``
        :param uptime: Milliseconds since process started format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cpu_time = cpu_time
        self.mem_resident = mem_resident
        self.mem_used = mem_used
        self.pid = pid
        self.ppid = ppid
        self.process_name = process_name
        self.start_time = start_time
        self.uptime = uptime
        VapiStruct.__init__(self)


NodeProcessProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.node_process_properties', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cpu_time': type.OptionalType(type.IntegerType()),
        'mem_resident': type.OptionalType(type.IntegerType()),
        'mem_used': type.OptionalType(type.IntegerType()),
        'pid': type.OptionalType(type.IntegerType()),
        'ppid': type.OptionalType(type.IntegerType()),
        'process_name': type.OptionalType(type.StringType()),
        'start_time': type.OptionalType(type.IntegerType()),
        'uptime': type.OptionalType(type.IntegerType()),
    },
    NodeProcessProperties,
    False,
    None))



class NodeProcessPropertiesListResult(VapiStruct):
    """
    Node process property query results

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`NodeProcessProperties` or ``None``
        :param results: Node process property results
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


NodeProcessPropertiesListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.node_process_properties_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NodeProcessProperties'))),
    },
    NodeProcessPropertiesListResult,
    False,
    None))



class NodeProperties(VapiStruct):
    """
    Node properties

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    EXPORT_TYPE_RESTRICTED = "RESTRICTED"
    """


    """
    EXPORT_TYPE_UNRESTRICTED = "UNRESTRICTED"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cli_timeout': 'cli_timeout',
                            'export_type': 'export_type',
                            'fully_qualified_domain_name': 'fully_qualified_domain_name',
                            'hostname': 'hostname',
                            'kernel_version': 'kernel_version',
                            'node_uuid': 'node_uuid',
                            'node_version': 'node_version',
                            'product_version': 'product_version',
                            'system_datetime': 'system_datetime',
                            'system_time': 'system_time',
                            'timezone': 'timezone',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cli_timeout=None,
                 export_type=None,
                 fully_qualified_domain_name=None,
                 hostname=None,
                 kernel_version=None,
                 node_uuid=None,
                 node_version=None,
                 product_version=None,
                 system_datetime=None,
                 system_time=None,
                 timezone=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cli_timeout: :class:`long` or ``None``
        :param cli_timeout: NSX CLI inactivity timeout, set to 0 to configure no timeout
            format: int64
        :type  export_type: :class:`str` or ``None``
        :param export_type: Possible values are: 
            
            * :attr:`NodeProperties.EXPORT_TYPE_RESTRICTED`
            * :attr:`NodeProperties.EXPORT_TYPE_UNRESTRICTED`
            
             Export restrictions in effect, if any
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  fully_qualified_domain_name: :class:`str` or ``None``
        :param fully_qualified_domain_name: Fully qualified domain name
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  hostname: :class:`str` or ``None``
        :param hostname: Host name or fully qualified domain name of node
        :type  kernel_version: :class:`str` or ``None``
        :param kernel_version: Kernel version
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  node_uuid: :class:`str` or ``None``
        :param node_uuid: Node Unique Identifier
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  node_version: :class:`str` or ``None``
        :param node_version: Node version
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  product_version: :class:`str` or ``None``
        :param product_version: Product version
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_datetime: :class:`str` or ``None``
        :param system_datetime: System date time in UTC
        :type  system_time: :class:`long` or ``None``
        :param system_time: Current time expressed in milliseconds since epoch format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  timezone: :class:`str` or ``None``
        :param timezone: Timezone
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cli_timeout = cli_timeout
        self.export_type = export_type
        self.fully_qualified_domain_name = fully_qualified_domain_name
        self.hostname = hostname
        self.kernel_version = kernel_version
        self.node_uuid = node_uuid
        self.node_version = node_version
        self.product_version = product_version
        self.system_datetime = system_datetime
        self.system_time = system_time
        self.timezone = timezone
        VapiStruct.__init__(self)


NodeProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.node_properties', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cli_timeout': type.OptionalType(type.IntegerType()),
        'export_type': type.OptionalType(type.StringType()),
        'fully_qualified_domain_name': type.OptionalType(type.StringType()),
        'hostname': type.OptionalType(type.StringType()),
        'kernel_version': type.OptionalType(type.StringType()),
        'node_uuid': type.OptionalType(type.StringType()),
        'node_version': type.OptionalType(type.StringType()),
        'product_version': type.OptionalType(type.StringType()),
        'system_datetime': type.OptionalType(type.StringType()),
        'system_time': type.OptionalType(type.IntegerType()),
        'timezone': type.OptionalType(type.StringType()),
    },
    NodeProperties,
    False,
    None))



class NodeProtonServiceProperties(VapiStruct):
    """
    Node service properties

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'service_name': 'service_name',
                            'service_properties': 'service_properties',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 service_name=None,
                 service_properties=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  service_name: :class:`str` or ``None``
        :param service_name: Service name
        :type  service_properties: :class:`LoggingServiceProperties` or ``None``
        :param service_properties: Service properties
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.service_name = service_name
        self.service_properties = service_properties
        VapiStruct.__init__(self)


NodeProtonServiceProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.node_proton_service_properties', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'service_name': type.OptionalType(type.StringType()),
        'service_properties': type.OptionalType(type.ReferenceType(__name__, 'LoggingServiceProperties')),
    },
    NodeProtonServiceProperties,
    False,
    None))



class NodeRouteProperties(VapiStruct):
    """
    Node network route properties

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    PROTO_UNSPEC = "unspec"
    """


    """
    PROTO_REDIRECT = "redirect"
    """


    """
    PROTO_KERNEL = "kernel"
    """


    """
    PROTO_BOOT = "boot"
    """


    """
    PROTO_STATIC = "static"
    """


    """
    PROTO_GATED = "gated"
    """


    """
    PROTO_RA = "ra"
    """


    """
    PROTO_MRT = "mrt"
    """


    """
    PROTO_ZEBRA = "zebra"
    """


    """
    PROTO_BIRD = "bird"
    """


    """
    PROTO_DNROUTED = "dnrouted"
    """


    """
    PROTO_XORP = "xorp"
    """


    """
    PROTO_NTK = "ntk"
    """


    """
    PROTO_DHCP = "dhcp"
    """


    """
    ROUTE_TYPE_DEFAULT = "default"
    """


    """
    ROUTE_TYPE_STATIC = "static"
    """


    """
    ROUTE_TYPE_BLACKHOLE = "blackhole"
    """


    """
    ROUTE_TYPE_PROHIBIT = "prohibit"
    """


    """
    ROUTE_TYPE_THROW = "throw"
    """


    """
    ROUTE_TYPE_UNREACHABLE = "unreachable"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'destination': 'destination',
                            'from_address': 'from_address',
                            'gateway': 'gateway',
                            'interface_id': 'interface_id',
                            'metric': 'metric',
                            'netmask': 'netmask',
                            'proto': 'proto',
                            'route_id': 'route_id',
                            'route_type': 'route_type',
                            'scope': 'scope',
                            'src': 'src',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 destination=None,
                 from_address=None,
                 gateway=None,
                 interface_id=None,
                 metric=None,
                 netmask=None,
                 proto=None,
                 route_id=None,
                 route_type=None,
                 scope=None,
                 src=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  destination: :class:`str` or ``None``
        :param destination: Destination covered by route
        :type  from_address: :class:`str` or ``None``
        :param from_address: From address
        :type  gateway: :class:`str` or ``None``
        :param gateway: Address of next hop
        :type  interface_id: :class:`str` or ``None``
        :param interface_id: Network interface id of route
        :type  metric: :class:`str` or ``None``
        :param metric: Metric value of route
        :type  netmask: :class:`str` or ``None``
        :param netmask: Netmask of destination covered by route
        :type  proto: :class:`str` or ``None``
        :param proto: Possible values are: 
            
            * :attr:`NodeRouteProperties.PROTO_UNSPEC`
            * :attr:`NodeRouteProperties.PROTO_REDIRECT`
            * :attr:`NodeRouteProperties.PROTO_KERNEL`
            * :attr:`NodeRouteProperties.PROTO_BOOT`
            * :attr:`NodeRouteProperties.PROTO_STATIC`
            * :attr:`NodeRouteProperties.PROTO_GATED`
            * :attr:`NodeRouteProperties.PROTO_RA`
            * :attr:`NodeRouteProperties.PROTO_MRT`
            * :attr:`NodeRouteProperties.PROTO_ZEBRA`
            * :attr:`NodeRouteProperties.PROTO_BIRD`
            * :attr:`NodeRouteProperties.PROTO_DNROUTED`
            * :attr:`NodeRouteProperties.PROTO_XORP`
            * :attr:`NodeRouteProperties.PROTO_NTK`
            * :attr:`NodeRouteProperties.PROTO_DHCP`
            
             Routing protocol identifier of route
        :type  route_id: :class:`str` or ``None``
        :param route_id: Unique identifier for the route
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  route_type: :class:`str` or ``None``
        :param route_type: Possible values are: 
            
            * :attr:`NodeRouteProperties.ROUTE_TYPE_DEFAULT`
            * :attr:`NodeRouteProperties.ROUTE_TYPE_STATIC`
            * :attr:`NodeRouteProperties.ROUTE_TYPE_BLACKHOLE`
            * :attr:`NodeRouteProperties.ROUTE_TYPE_PROHIBIT`
            * :attr:`NodeRouteProperties.ROUTE_TYPE_THROW`
            * :attr:`NodeRouteProperties.ROUTE_TYPE_UNREACHABLE`
            
             Route type
        :type  scope: :class:`str` or ``None``
        :param scope: Scope of destinations covered by route
        :type  src: :class:`str` or ``None``
        :param src: Source address to prefer when sending to destinations of route
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.destination = destination
        self.from_address = from_address
        self.gateway = gateway
        self.interface_id = interface_id
        self.metric = metric
        self.netmask = netmask
        self.proto = proto
        self.route_id = route_id
        self.route_type = route_type
        self.scope = scope
        self.src = src
        VapiStruct.__init__(self)


NodeRouteProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.node_route_properties', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'destination': type.OptionalType(type.StringType()),
        'from_address': type.OptionalType(type.StringType()),
        'gateway': type.OptionalType(type.StringType()),
        'interface_id': type.OptionalType(type.StringType()),
        'metric': type.OptionalType(type.StringType()),
        'netmask': type.OptionalType(type.StringType()),
        'proto': type.OptionalType(type.StringType()),
        'route_id': type.OptionalType(type.StringType()),
        'route_type': type.OptionalType(type.StringType()),
        'scope': type.OptionalType(type.StringType()),
        'src': type.OptionalType(type.StringType()),
    },
    NodeRouteProperties,
    False,
    None))



class NodeRoutePropertiesListResult(VapiStruct):
    """
    Node network route properties list results

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`NodeRouteProperties` or ``None``
        :param results: Node route property results
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


NodeRoutePropertiesListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.node_route_properties_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NodeRouteProperties'))),
    },
    NodeRoutePropertiesListResult,
    False,
    None))



class NodeRtepIpsConfig(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'member_index': 'member_index',
                            'rtep_ips': 'rtep_ips',
                            'transport_node_id': 'transport_node_id',
                            }

    def __init__(self,
                 member_index=None,
                 rtep_ips=None,
                 transport_node_id=None,
                ):
        """
        :type  member_index: :class:`long` or ``None``
        :param member_index: System generated index for cluster member format: int32
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  rtep_ips: :class:`list` of :class:`str` or ``None``
        :param rtep_ips: Remote tunnel endpoint ip address. format: ip
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  transport_node_id: :class:`str` or ``None``
        :param transport_node_id: Identifier of the transport node backed by an Edge node
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.member_index = member_index
        self.rtep_ips = rtep_ips
        self.transport_node_id = transport_node_id
        VapiStruct.__init__(self)


NodeRtepIpsConfig._set_binding_type(type.StructType(
    'com.vmware.nsx.model.node_rtep_ips_config', {
        'member_index': type.OptionalType(type.IntegerType()),
        'rtep_ips': type.OptionalType(type.ListType(type.StringType())),
        'transport_node_id': type.OptionalType(type.StringType()),
    },
    NodeRtepIpsConfig,
    False,
    None))



class NodeSearchDomainsProperties(VapiStruct):
    """
    Node network search domains properties

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'search_domains': 'search_domains',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 search_domains=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  search_domains: :class:`list` of :class:`str` or ``None``
        :param search_domains: Search domains
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.search_domains = search_domains
        VapiStruct.__init__(self)


NodeSearchDomainsProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.node_search_domains_properties', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'search_domains': type.OptionalType(type.ListType(type.StringType())),
    },
    NodeSearchDomainsProperties,
    False,
    None))



class NodeServiceProperties(VapiStruct):
    """
    Node service properties

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'service_name': 'service_name',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 service_name=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  service_name: :class:`str` or ``None``
        :param service_name: Service name
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.service_name = service_name
        VapiStruct.__init__(self)


NodeServiceProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.node_service_properties', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'service_name': type.OptionalType(type.StringType()),
    },
    NodeServiceProperties,
    False,
    None))



class NodeServicePropertiesListResult(VapiStruct):
    """
    Node service property query results

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`NodeServiceProperties` or ``None``
        :param results: Node service property results
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


NodeServicePropertiesListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.node_service_properties_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NodeServiceProperties'))),
    },
    NodeServicePropertiesListResult,
    False,
    None))



class NodeServiceStatusProperties(VapiStruct):
    """
    Node service status properties

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    HEALTH_STABLE = "STABLE"
    """


    """
    HEALTH_DEGRADED = "DEGRADED"
    """


    """
    MONITOR_RUNTIME_STATE_RUNNING = "running"
    """


    """
    MONITOR_RUNTIME_STATE_STOPPED = "stopped"
    """


    """
    RUNTIME_STATE_RUNNING = "running"
    """


    """
    RUNTIME_STATE_STOPPED = "stopped"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'health': 'health',
                            'monitor_pid': 'monitor_pid',
                            'monitor_runtime_state': 'monitor_runtime_state',
                            'pids': 'pids',
                            'reason': 'reason',
                            'runtime_state': 'runtime_state',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 health=None,
                 monitor_pid=None,
                 monitor_runtime_state=None,
                 pids=None,
                 reason=None,
                 runtime_state=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  health: :class:`str` or ``None``
        :param health: Possible values are: 
            
            * :attr:`NodeServiceStatusProperties.HEALTH_STABLE`
            * :attr:`NodeServiceStatusProperties.HEALTH_DEGRADED`
            
             Service health in addition to runtime_state
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  monitor_pid: :class:`long` or ``None``
        :param monitor_pid: Service monitor process id format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  monitor_runtime_state: :class:`str` or ``None``
        :param monitor_runtime_state: Possible values are: 
            
            * :attr:`NodeServiceStatusProperties.MONITOR_RUNTIME_STATE_RUNNING`
            * :attr:`NodeServiceStatusProperties.MONITOR_RUNTIME_STATE_STOPPED`
            
             Service monitor runtime state
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  pids: :class:`list` of :class:`long` or ``None``
        :param pids: Service process ids format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  reason: :class:`str` or ``None``
        :param reason: Reason for service degradation
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  runtime_state: :class:`str` or ``None``
        :param runtime_state: Possible values are: 
            
            * :attr:`NodeServiceStatusProperties.RUNTIME_STATE_RUNNING`
            * :attr:`NodeServiceStatusProperties.RUNTIME_STATE_STOPPED`
            
             Service runtime state
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.health = health
        self.monitor_pid = monitor_pid
        self.monitor_runtime_state = monitor_runtime_state
        self.pids = pids
        self.reason = reason
        self.runtime_state = runtime_state
        VapiStruct.__init__(self)


NodeServiceStatusProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.node_service_status_properties', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'health': type.OptionalType(type.StringType()),
        'monitor_pid': type.OptionalType(type.IntegerType()),
        'monitor_runtime_state': type.OptionalType(type.StringType()),
        'pids': type.OptionalType(type.ListType(type.IntegerType())),
        'reason': type.OptionalType(type.StringType()),
        'runtime_state': type.OptionalType(type.StringType()),
    },
    NodeServiceStatusProperties,
    False,
    None))



class NodeSnmpServiceProperties(VapiStruct):
    """
    Node SNMP service properties

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'service_name': 'service_name',
                            'service_properties': 'service_properties',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 service_name=None,
                 service_properties=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  service_name: :class:`str` or ``None``
        :param service_name: Service name
        :type  service_properties: :class:`SnmpServiceProperties` or ``None``
        :param service_properties: SNMP Service properties
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.service_name = service_name
        self.service_properties = service_properties
        VapiStruct.__init__(self)


NodeSnmpServiceProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.node_snmp_service_properties', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'service_name': type.OptionalType(type.StringType()),
        'service_properties': type.OptionalType(type.ReferenceType(__name__, 'SnmpServiceProperties')),
    },
    NodeSnmpServiceProperties,
    False,
    None))



class NodeSnmpV3EngineID(VapiStruct):
    """
    SNMP V3 Engine Id

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'service_name': 'service_name',
                            'v3_engine_id': 'v3_engine_id',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 service_name=None,
                 v3_engine_id=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  service_name: :class:`str` or ``None``
        :param service_name: Service name
        :type  v3_engine_id: :class:`str` or ``None``
        :param v3_engine_id: SNMP v3 engine id
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.service_name = service_name
        self.v3_engine_id = v3_engine_id
        VapiStruct.__init__(self)


NodeSnmpV3EngineID._set_binding_type(type.StructType(
    'com.vmware.nsx.model.node_snmp_v3_engine_ID', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'service_name': type.OptionalType(type.StringType()),
        'v3_engine_id': type.OptionalType(type.StringType()),
    },
    NodeSnmpV3EngineID,
    False,
    None))



class NodeSshServiceProperties(VapiStruct):
    """
    Node SSH service properties

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'service_name': 'service_name',
                            'service_properties': 'service_properties',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 service_name=None,
                 service_properties=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  service_name: :class:`str` or ``None``
        :param service_name: Service name
        :type  service_properties: :class:`SshServiceProperties` or ``None``
        :param service_properties: SSH Service properties
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.service_name = service_name
        self.service_properties = service_properties
        VapiStruct.__init__(self)


NodeSshServiceProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.node_ssh_service_properties', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'service_name': type.OptionalType(type.StringType()),
        'service_properties': type.OptionalType(type.ReferenceType(__name__, 'SshServiceProperties')),
    },
    NodeSshServiceProperties,
    False,
    None))



class NodeStatus(VapiStruct):
    """
    Runtime status information of the fabric node.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    HOST_NODE_DEPLOYMENT_STATUS_NOT_PREPARED = "NOT_PREPARED"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_INSTALL_IN_PROGRESS = "INSTALL_IN_PROGRESS"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_INSTALL_FAILED = "INSTALL_FAILED"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_INSTALL_SUCCESSFUL = "INSTALL_SUCCESSFUL"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_UNINSTALL_IN_PROGRESS = "UNINSTALL_IN_PROGRESS"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_UNINSTALL_FAILED = "UNINSTALL_FAILED"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_UNINSTALL_SUCCESSFUL = "UNINSTALL_SUCCESSFUL"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_UNINSTALL_SCHEDULED = "UNINSTALL_SCHEDULED"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_UPGRADE_IN_PROGRESS = "UPGRADE_IN_PROGRESS"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_UPGRADE_FAILED = "UPGRADE_FAILED"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_PENDING_UPGRADE = "PENDING_UPGRADE"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_NOT_AVAILABLE = "NOT_AVAILABLE"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_VM_DEPLOYMENT_QUEUED = "VM_DEPLOYMENT_QUEUED"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_VM_DEPLOYMENT_IN_PROGRESS = "VM_DEPLOYMENT_IN_PROGRESS"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_VM_DEPLOYMENT_FAILED = "VM_DEPLOYMENT_FAILED"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_VM_POWER_ON_IN_PROGRESS = "VM_POWER_ON_IN_PROGRESS"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_VM_POWER_ON_FAILED = "VM_POWER_ON_FAILED"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_REGISTRATION_PENDING = "REGISTRATION_PENDING"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_NODE_NOT_READY = "NODE_NOT_READY"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_NODE_READY = "NODE_READY"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_VM_POWER_OFF_IN_PROGRESS = "VM_POWER_OFF_IN_PROGRESS"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_VM_POWER_OFF_FAILED = "VM_POWER_OFF_FAILED"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_VM_UNDEPLOY_IN_PROGRESS = "VM_UNDEPLOY_IN_PROGRESS"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_VM_UNDEPLOY_FAILED = "VM_UNDEPLOY_FAILED"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_VM_UNDEPLOY_SUCCESSFUL = "VM_UNDEPLOY_SUCCESSFUL"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_EDGE_CONFIG_ERROR = "EDGE_CONFIG_ERROR"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_VM_DEPLOYMENT_RESTARTED = "VM_DEPLOYMENT_RESTARTED"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_REGISTRATION_FAILED = "REGISTRATION_FAILED"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_HOST_DISCONNECTED = "HOST_DISCONNECTED"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_POWERED_OFF = "POWERED_OFF"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_TRANSPORT_NODE_SYNC_PENDING = "TRANSPORT_NODE_SYNC_PENDING"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_TRANSPORT_NODE_CONFIGURATION_MISSING = "TRANSPORT_NODE_CONFIGURATION_MISSING"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_EDGE_HARDWARE_NOT_SUPPORTED = "EDGE_HARDWARE_NOT_SUPPORTED"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_MULTIPLE_OVERLAY_TZS_NOT_SUPPORTED = "MULTIPLE_OVERLAY_TZS_NOT_SUPPORTED"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_TN_OVERLAY_TZ_IN_USE_BY_EDGE_CLUSTER = "TN_OVERLAY_TZ_IN_USE_BY_EDGE_CLUSTER"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_TZ_ENDPOINTS_NOT_SPECIFIED = "TZ_ENDPOINTS_NOT_SPECIFIED"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_NO_PNIC_PREPARED_IN_EDGE = "NO_PNIC_PREPARED_IN_EDGE"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_APPLIANCE_INTERNAL_ERROR = "APPLIANCE_INTERNAL_ERROR"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_VTEP_DHCP_NOT_SUPPORTED = "VTEP_DHCP_NOT_SUPPORTED"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_UNSUPPORTED_HOST_SWITCH_PROFILE = "UNSUPPORTED_HOST_SWITCH_PROFILE"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_UPLINK_HOST_SWITCH_PROFILE_NOT_SPECIFIED = "UPLINK_HOST_SWITCH_PROFILE_NOT_SPECIFIED"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_HOSTSWITCH_PROFILE_NOT_FOUND = "HOSTSWITCH_PROFILE_NOT_FOUND"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_LLDP_SEND_ENABLED_NOT_SUPPORTED = "LLDP_SEND_ENABLED_NOT_SUPPORTED"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_UNSUPPORTED_NAMED_TEAMING_POLICY = "UNSUPPORTED_NAMED_TEAMING_POLICY"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_MULTIPLE_UPLINKS_IN_NAMED_TEAMING_NOT_SUPPORTED_IF_UPLINK_IN_DEFAULT_TEAMING = "MULTIPLE_UPLINKS_IN_NAMED_TEAMING_NOT_SUPPORTED_IF_UPLINK_IN_DEFAULT_TEAMING"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_LBSRCID_NOT_SUPPORTED_FOR_EDGE_VM = "LBSRCID_NOT_SUPPORTED_FOR_EDGE_VM"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_LACP_NOT_SUPPORTED_FOR_EDGE_VM = "LACP_NOT_SUPPORTED_FOR_EDGE_VM"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_STANDBY_UPLINKS_NOT_SUPPORTED_FOR_EDGE_VM = "STANDBY_UPLINKS_NOT_SUPPORTED_FOR_EDGE_VM"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_MULTIPLE_ACTIVE_UPLINKS_NOT_SUPPORTED_FOR_EDGE = "MULTIPLE_ACTIVE_UPLINKS_NOT_SUPPORTED_FOR_EDGE"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_UNSUPPORTED_LACP_LB_ALGO_FOR_NODE = "UNSUPPORTED_LACP_LB_ALGO_FOR_NODE"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_EDGE_NODE_VERSION_NOT_SUPPORTED = "EDGE_NODE_VERSION_NOT_SUPPORTED"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_NO_PNIC_SPECIFIED_IN_TN = "NO_PNIC_SPECIFIED_IN_TN"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_INVALID_PNIC_DEVICE_NAME = "INVALID_PNIC_DEVICE_NAME"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_TRANSPORT_NODE_READY = "TRANSPORT_NODE_READY"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_UNSUPPORTED_DEFAULT_TEAMING_POLICY = "UNSUPPORTED_DEFAULT_TEAMING_POLICY"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_MPA_DISCONNECTED = "MPA_DISCONNECTED"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_VM_NETWORK_EDIT_PENDING = "VM_NETWORK_EDIT_PENDING"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_VM_RENAME_PENDING = "VM_RENAME_PENDING"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_VM_CONFIG_EDIT_PENDING = "VM_CONFIG_EDIT_PENDING"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_VM_NETWORK_EDIT_FAILED = "VM_NETWORK_EDIT_FAILED"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_VM_RENAME_FAILED = "VM_RENAME_FAILED"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_VM_CONFIG_EDIT_FAILED = "VM_CONFIG_EDIT_FAILED"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_VM_CONFIG_DISCREPANCY = "VM_CONFIG_DISCREPANCY"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_VM_NODE_REFRESH_FAILED = "VM_NODE_REFRESH_FAILED"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_VM_PLACEMENT_REFRESH_FAILED = "VM_PLACEMENT_REFRESH_FAILED"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_REGISTRATION_TIMEDOUT = "REGISTRATION_TIMEDOUT"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_LOGICAL_SWITCH_NAMED_TEAMING_HAS_NO_PNIC_BACKING = "LOGICAL_SWITCH_NAMED_TEAMING_HAS_NO_PNIC_BACKING"
    """


    """
    HOST_NODE_DEPLOYMENT_STATUS_UPLINK_FROM_TEAMING_POLICY_NOT_MAPPED = "UPLINK_FROM_TEAMING_POLICY_NOT_MAPPED"
    """


    """
    LCP_CONNECTIVITY_STATUS_UP = "UP"
    """


    """
    LCP_CONNECTIVITY_STATUS_DOWN = "DOWN"
    """


    """
    LCP_CONNECTIVITY_STATUS_DEGRADED = "DEGRADED"
    """


    """
    LCP_CONNECTIVITY_STATUS_UNKNOWN = "UNKNOWN"
    """


    """
    MAINTENANCE_MODE_OFF = "OFF"
    """


    """
    MAINTENANCE_MODE_ENTERING = "ENTERING"
    """


    """
    MAINTENANCE_MODE_ON = "ON"
    """


    """
    MAINTENANCE_MODE_EXITING = "EXITING"
    """


    """
    MPA_CONNECTIVITY_STATUS_UP = "UP"
    """


    """
    MPA_CONNECTIVITY_STATUS_DOWN = "DOWN"
    """


    """
    MPA_CONNECTIVITY_STATUS_UNKNOWN = "UNKNOWN"
    """


    """



    _canonical_to_pep_names = {
                            'external_id': 'external_id',
                            'host_node_deployment_status': 'host_node_deployment_status',
                            'inventory_sync_paused': 'inventory_sync_paused',
                            'inventory_sync_reenable_time': 'inventory_sync_reenable_time',
                            'last_heartbeat_timestamp': 'last_heartbeat_timestamp',
                            'last_sync_time': 'last_sync_time',
                            'lcp_connectivity_status': 'lcp_connectivity_status',
                            'lcp_connectivity_status_details': 'lcp_connectivity_status_details',
                            'maintenance_mode': 'maintenance_mode',
                            'mpa_connectivity_status': 'mpa_connectivity_status',
                            'mpa_connectivity_status_details': 'mpa_connectivity_status_details',
                            'software_version': 'software_version',
                            'system_status': 'system_status',
                            }

    def __init__(self,
                 external_id=None,
                 host_node_deployment_status=None,
                 inventory_sync_paused=None,
                 inventory_sync_reenable_time=None,
                 last_heartbeat_timestamp=None,
                 last_sync_time=None,
                 lcp_connectivity_status=None,
                 lcp_connectivity_status_details=None,
                 maintenance_mode=None,
                 mpa_connectivity_status=None,
                 mpa_connectivity_status_details=None,
                 software_version=None,
                 system_status=None,
                ):
        """
        :type  external_id: :class:`str` or ``None``
        :param external_id: HostNode external id
        :type  host_node_deployment_status: :class:`str` or ``None``
        :param host_node_deployment_status: Possible values are: 
            
            * :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_NOT_PREPARED`
            *
              :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_INSTALL_IN_PROGRESS`
            * :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_INSTALL_FAILED`
            * :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_INSTALL_SUCCESSFUL`
            *
              :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_UNINSTALL_IN_PROGRESS`
            * :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_UNINSTALL_FAILED`
            *
              :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_UNINSTALL_SUCCESSFUL`
            *
              :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_UNINSTALL_SCHEDULED`
            *
              :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_UPGRADE_IN_PROGRESS`
            * :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_UPGRADE_FAILED`
            * :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_PENDING_UPGRADE`
            * :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_NOT_AVAILABLE`
            *
              :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_VM_DEPLOYMENT_QUEUED`
            *
              :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_VM_DEPLOYMENT_IN_PROGRESS`
            *
              :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_VM_DEPLOYMENT_FAILED`
            *
              :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_VM_POWER_ON_IN_PROGRESS`
            * :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_VM_POWER_ON_FAILED`
            *
              :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_REGISTRATION_PENDING`
            * :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_NODE_NOT_READY`
            * :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_NODE_READY`
            *
              :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_VM_POWER_OFF_IN_PROGRESS`
            *
              :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_VM_POWER_OFF_FAILED`
            *
              :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_VM_UNDEPLOY_IN_PROGRESS`
            * :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_VM_UNDEPLOY_FAILED`
            *
              :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_VM_UNDEPLOY_SUCCESSFUL`
            * :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_EDGE_CONFIG_ERROR`
            *
              :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_VM_DEPLOYMENT_RESTARTED`
            *
              :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_REGISTRATION_FAILED`
            * :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_HOST_DISCONNECTED`
            * :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_POWERED_OFF`
            *
              :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_TRANSPORT_NODE_SYNC_PENDING`
            *
              :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_TRANSPORT_NODE_CONFIGURATION_MISSING`
            *
              :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_EDGE_HARDWARE_NOT_SUPPORTED`
            *
              :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_MULTIPLE_OVERLAY_TZS_NOT_SUPPORTED`
            *
              :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_TN_OVERLAY_TZ_IN_USE_BY_EDGE_CLUSTER`
            *
              :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_TZ_ENDPOINTS_NOT_SPECIFIED`
            *
              :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_NO_PNIC_PREPARED_IN_EDGE`
            *
              :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_APPLIANCE_INTERNAL_ERROR`
            *
              :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_VTEP_DHCP_NOT_SUPPORTED`
            *
              :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_UNSUPPORTED_HOST_SWITCH_PROFILE`
            *
              :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_UPLINK_HOST_SWITCH_PROFILE_NOT_SPECIFIED`
            *
              :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_HOSTSWITCH_PROFILE_NOT_FOUND`
            *
              :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_LLDP_SEND_ENABLED_NOT_SUPPORTED`
            *
              :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_UNSUPPORTED_NAMED_TEAMING_POLICY`
            *
              :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_MULTIPLE_UPLINKS_IN_NAMED_TEAMING_NOT_SUPPORTED_IF_UPLINK_IN_DEFAULT_TEAMING`
            *
              :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_LBSRCID_NOT_SUPPORTED_FOR_EDGE_VM`
            *
              :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_LACP_NOT_SUPPORTED_FOR_EDGE_VM`
            *
              :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_STANDBY_UPLINKS_NOT_SUPPORTED_FOR_EDGE_VM`
            *
              :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_MULTIPLE_ACTIVE_UPLINKS_NOT_SUPPORTED_FOR_EDGE`
            *
              :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_UNSUPPORTED_LACP_LB_ALGO_FOR_NODE`
            *
              :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_EDGE_NODE_VERSION_NOT_SUPPORTED`
            *
              :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_NO_PNIC_SPECIFIED_IN_TN`
            *
              :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_INVALID_PNIC_DEVICE_NAME`
            *
              :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_TRANSPORT_NODE_READY`
            *
              :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_UNSUPPORTED_DEFAULT_TEAMING_POLICY`
            * :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_MPA_DISCONNECTED`
            *
              :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_VM_NETWORK_EDIT_PENDING`
            * :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_VM_RENAME_PENDING`
            *
              :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_VM_CONFIG_EDIT_PENDING`
            *
              :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_VM_NETWORK_EDIT_FAILED`
            * :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_VM_RENAME_FAILED`
            *
              :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_VM_CONFIG_EDIT_FAILED`
            *
              :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_VM_CONFIG_DISCREPANCY`
            *
              :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_VM_NODE_REFRESH_FAILED`
            *
              :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_VM_PLACEMENT_REFRESH_FAILED`
            *
              :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_REGISTRATION_TIMEDOUT`
            *
              :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_LOGICAL_SWITCH_NAMED_TEAMING_HAS_NO_PNIC_BACKING`
            *
              :attr:`NodeStatus.HOST_NODE_DEPLOYMENT_STATUS_UPLINK_FROM_TEAMING_POLICY_NOT_MAPPED`
            
            This enum specifies the current nsx install state for host node or
            current deployment and ready state for edge node. The ready status
            'NODE_READY' indicates whether edge node is ready to become a
            transport node. The status 'EDGE_CONFIG_ERROR' indicates that edge
            hardware or underlying host is not supported. After all fabric
            level operations are done for an edge node, this value indicates
            transport node related configuration issues and state as relevant.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  inventory_sync_paused: :class:`bool` or ``None``
        :param inventory_sync_paused: Is true if inventory sync is paused else false
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  inventory_sync_reenable_time: :class:`long` or ``None``
        :param inventory_sync_reenable_time: Inventory sync auto re-enable target time, in epoch milis format:
            int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_heartbeat_timestamp: :class:`long` or ``None``
        :param last_heartbeat_timestamp: Timestamp of the last heartbeat status change, in epoch
            milliseconds. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_sync_time: :class:`long` or ``None``
        :param last_sync_time: Timestamp of the last successful update of Inventory, in epoch
            milliseconds. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  lcp_connectivity_status: :class:`str` or ``None``
        :param lcp_connectivity_status: Possible values are: 
            
            * :attr:`NodeStatus.LCP_CONNECTIVITY_STATUS_UP`
            * :attr:`NodeStatus.LCP_CONNECTIVITY_STATUS_DOWN`
            * :attr:`NodeStatus.LCP_CONNECTIVITY_STATUS_DEGRADED`
            * :attr:`NodeStatus.LCP_CONNECTIVITY_STATUS_UNKNOWN`
            
            Indicates the fabric node's LCP<->CCP channel connectivity status,
            UP, DOWN, DEGRADED, UNKNOWN.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  lcp_connectivity_status_details: :class:`list` of :class:`ControlConnStatus` or ``None``
        :param lcp_connectivity_status_details: Details, if any, about the current LCP<->CCP channel connectivity
            status of the fabric node.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  maintenance_mode: :class:`str` or ``None``
        :param maintenance_mode: Possible values are: 
            
            * :attr:`NodeStatus.MAINTENANCE_MODE_OFF`
            * :attr:`NodeStatus.MAINTENANCE_MODE_ENTERING`
            * :attr:`NodeStatus.MAINTENANCE_MODE_ON`
            * :attr:`NodeStatus.MAINTENANCE_MODE_EXITING`
            
            Indicates the fabric node's status of maintenance mode, OFF,
            ENTERING, ON, EXITING.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  mpa_connectivity_status: :class:`str` or ``None``
        :param mpa_connectivity_status: Possible values are: 
            
            * :attr:`NodeStatus.MPA_CONNECTIVITY_STATUS_UP`
            * :attr:`NodeStatus.MPA_CONNECTIVITY_STATUS_DOWN`
            * :attr:`NodeStatus.MPA_CONNECTIVITY_STATUS_UNKNOWN`
            
            Indicates the fabric node's MP<->MPA channel connectivity status,
            UP, DOWN, UNKNOWN.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  mpa_connectivity_status_details: :class:`str` or ``None``
        :param mpa_connectivity_status_details: Details, if any, about the current MP<->MPA channel connectivity
            status of the fabric node.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  software_version: :class:`str` or ``None``
        :param software_version: Software version of the fabric node.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_status: :class:`NodeStatusProperties` or ``None``
        :param system_status: Node status properties
        """
        self.external_id = external_id
        self.host_node_deployment_status = host_node_deployment_status
        self.inventory_sync_paused = inventory_sync_paused
        self.inventory_sync_reenable_time = inventory_sync_reenable_time
        self.last_heartbeat_timestamp = last_heartbeat_timestamp
        self.last_sync_time = last_sync_time
        self.lcp_connectivity_status = lcp_connectivity_status
        self.lcp_connectivity_status_details = lcp_connectivity_status_details
        self.maintenance_mode = maintenance_mode
        self.mpa_connectivity_status = mpa_connectivity_status
        self.mpa_connectivity_status_details = mpa_connectivity_status_details
        self.software_version = software_version
        self.system_status = system_status
        VapiStruct.__init__(self)


NodeStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.node_status', {
        'external_id': type.OptionalType(type.StringType()),
        'host_node_deployment_status': type.OptionalType(type.StringType()),
        'inventory_sync_paused': type.OptionalType(type.BooleanType()),
        'inventory_sync_reenable_time': type.OptionalType(type.IntegerType()),
        'last_heartbeat_timestamp': type.OptionalType(type.IntegerType()),
        'last_sync_time': type.OptionalType(type.IntegerType()),
        'lcp_connectivity_status': type.OptionalType(type.StringType()),
        'lcp_connectivity_status_details': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ControlConnStatus'))),
        'maintenance_mode': type.OptionalType(type.StringType()),
        'mpa_connectivity_status': type.OptionalType(type.StringType()),
        'mpa_connectivity_status_details': type.OptionalType(type.StringType()),
        'software_version': type.OptionalType(type.StringType()),
        'system_status': type.OptionalType(type.ReferenceType(__name__, 'NodeStatusProperties')),
    },
    NodeStatus,
    False,
    None))



class NodeStatusListResult(VapiStruct):
    """
    Node Status list result

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'results': 'results',
                            }

    def __init__(self,
                 results=None,
                ):
        """
        :type  results: :class:`list` of :class:`NodeStatus` or ``None``
        :param results: Node Status list results
        """
        self.results = results
        VapiStruct.__init__(self)


NodeStatusListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.node_status_list_result', {
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NodeStatus'))),
    },
    NodeStatusListResult,
    False,
    None))



class NodeStatusProperties(VapiStruct):
    """
    Node status properties

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    SOURCE_REALTIME = "realtime"
    """


    """
    SOURCE_CACHED = "cached"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cpu_cores': 'cpu_cores',
                            'cpu_usage': 'cpu_usage',
                            'disk_space_total': 'disk_space_total',
                            'disk_space_used': 'disk_space_used',
                            'dpdk_cpu_cores': 'dpdk_cpu_cores',
                            'edge_mem_usage': 'edge_mem_usage',
                            'file_systems': 'file_systems',
                            'load_average': 'load_average',
                            'mem_cache': 'mem_cache',
                            'mem_total': 'mem_total',
                            'mem_used': 'mem_used',
                            'non_dpdk_cpu_cores': 'non_dpdk_cpu_cores',
                            'source': 'source',
                            'swap_total': 'swap_total',
                            'swap_used': 'swap_used',
                            'system_time': 'system_time',
                            'uptime': 'uptime',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cpu_cores=None,
                 cpu_usage=None,
                 disk_space_total=None,
                 disk_space_used=None,
                 dpdk_cpu_cores=None,
                 edge_mem_usage=None,
                 file_systems=None,
                 load_average=None,
                 mem_cache=None,
                 mem_total=None,
                 mem_used=None,
                 non_dpdk_cpu_cores=None,
                 source=None,
                 swap_total=None,
                 swap_used=None,
                 system_time=None,
                 uptime=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cpu_cores: :class:`long` or ``None``
        :param cpu_cores: Number of CPU cores on the system format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  cpu_usage: :class:`CpuUsage` or ``None``
        :param cpu_usage: Highest and average usage of DPDK and non-DPDK core of Edge Node.
        :type  disk_space_total: :class:`long` or ``None``
        :param disk_space_total: Amount of disk space available on the system, in kilobytes. format:
            int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  disk_space_used: :class:`long` or ``None``
        :param disk_space_used: Amount of disk space in use on the system, in kilobytes format:
            int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  dpdk_cpu_cores: :class:`long` or ``None``
        :param dpdk_cpu_cores: Number of DPDK cores on Edge Node which are used for packet IO
            processing. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  edge_mem_usage: :class:`EdgeTransportNodeMemoryUsage` or ``None``
        :param edge_mem_usage: Point in time usage of system, datapath, swap and cache memory in
            edge node. Valid only for Edge transport node.
        :type  file_systems: :class:`list` of :class:`NodeFileSystemProperties` or ``None``
        :param file_systems: File systems configured on the system
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  load_average: :class:`list` of :class:`float` or ``None``
        :param load_average: One, five, and fifteen minute load averages for the system
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  mem_cache: :class:`long` or ``None``
        :param mem_cache: Amount of RAM on the system that can be flushed out to disk, in
            kilobytes format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  mem_total: :class:`long` or ``None``
        :param mem_total: Amount of RAM allocated to the system, in kilobytes format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  mem_used: :class:`long` or ``None``
        :param mem_used: Amount of RAM in use on the system, in kilobytes format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  non_dpdk_cpu_cores: :class:`long` or ``None``
        :param non_dpdk_cpu_cores: Number of non-DPDK cores on Edge Node. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  source: :class:`str` or ``None``
        :param source: Possible values are: 
            
            * :attr:`NodeStatusProperties.SOURCE_REALTIME`
            * :attr:`NodeStatusProperties.SOURCE_CACHED`
            
             Source of status data.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  swap_total: :class:`long` or ``None``
        :param swap_total: Amount of disk available for swap, in kilobytes format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  swap_used: :class:`long` or ``None``
        :param swap_used: Amount of swap disk in use, in kilobytes format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_time: :class:`long` or ``None``
        :param system_time: Current time expressed in milliseconds since epoch format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  uptime: :class:`long` or ``None``
        :param uptime: Milliseconds since system start format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cpu_cores = cpu_cores
        self.cpu_usage = cpu_usage
        self.disk_space_total = disk_space_total
        self.disk_space_used = disk_space_used
        self.dpdk_cpu_cores = dpdk_cpu_cores
        self.edge_mem_usage = edge_mem_usage
        self.file_systems = file_systems
        self.load_average = load_average
        self.mem_cache = mem_cache
        self.mem_total = mem_total
        self.mem_used = mem_used
        self.non_dpdk_cpu_cores = non_dpdk_cpu_cores
        self.source = source
        self.swap_total = swap_total
        self.swap_used = swap_used
        self.system_time = system_time
        self.uptime = uptime
        VapiStruct.__init__(self)


NodeStatusProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.node_status_properties', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cpu_cores': type.OptionalType(type.IntegerType()),
        'cpu_usage': type.OptionalType(type.ReferenceType(__name__, 'CpuUsage')),
        'disk_space_total': type.OptionalType(type.IntegerType()),
        'disk_space_used': type.OptionalType(type.IntegerType()),
        'dpdk_cpu_cores': type.OptionalType(type.IntegerType()),
        'edge_mem_usage': type.OptionalType(type.ReferenceType(__name__, 'EdgeTransportNodeMemoryUsage')),
        'file_systems': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NodeFileSystemProperties'))),
        'load_average': type.OptionalType(type.ListType(type.DoubleType())),
        'mem_cache': type.OptionalType(type.IntegerType()),
        'mem_total': type.OptionalType(type.IntegerType()),
        'mem_used': type.OptionalType(type.IntegerType()),
        'non_dpdk_cpu_cores': type.OptionalType(type.IntegerType()),
        'source': type.OptionalType(type.StringType()),
        'swap_total': type.OptionalType(type.IntegerType()),
        'swap_used': type.OptionalType(type.IntegerType()),
        'system_time': type.OptionalType(type.IntegerType()),
        'uptime': type.OptionalType(type.IntegerType()),
    },
    NodeStatusProperties,
    False,
    None))



class NodeSummary(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'component_version': 'component_version',
                            'node_count': 'node_count',
                            'type': 'type',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 component_version=None,
                 node_count=None,
                 type=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  component_version: :class:`str` or ``None``
        :param component_version: Component version
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  node_count: :class:`long` or ``None``
        :param node_count: Number of nodes of the type and at the component version format:
            int32
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  type: :class:`str` or ``None``
        :param type: Node type
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.component_version = component_version
        self.node_count = node_count
        self.type = type
        VapiStruct.__init__(self)


NodeSummary._set_binding_type(type.StructType(
    'com.vmware.nsx.model.node_summary', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'component_version': type.OptionalType(type.StringType()),
        'node_count': type.OptionalType(type.IntegerType()),
        'type': type.OptionalType(type.StringType()),
    },
    NodeSummary,
    False,
    None))



class NodeSummaryList(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'results': 'results',
                            }

    def __init__(self,
                 results=None,
                ):
        """
        :type  results: :class:`list` of :class:`NodeSummary` or ``None``
        :param results: List of Node Summary
        """
        self.results = results
        VapiStruct.__init__(self)


NodeSummaryList._set_binding_type(type.StructType(
    'com.vmware.nsx.model.node_summary_list', {
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NodeSummary'))),
    },
    NodeSummaryList,
    False,
    None))



class NodeSyslogExporterProperties(VapiStruct):
    """
    Node syslog exporter properties

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    FACILITIES_KERN = "KERN"
    """


    """
    FACILITIES_USER = "USER"
    """


    """
    FACILITIES_MAIL = "MAIL"
    """


    """
    FACILITIES_DAEMON = "DAEMON"
    """


    """
    FACILITIES_AUTH = "AUTH"
    """


    """
    FACILITIES_SYSLOG = "SYSLOG"
    """


    """
    FACILITIES_LPR = "LPR"
    """


    """
    FACILITIES_NEWS = "NEWS"
    """


    """
    FACILITIES_UUCP = "UUCP"
    """


    """
    FACILITIES_AUTHPRIV = "AUTHPRIV"
    """


    """
    FACILITIES_FTP = "FTP"
    """


    """
    FACILITIES_LOGALERT = "LOGALERT"
    """


    """
    FACILITIES_CRON = "CRON"
    """


    """
    FACILITIES_LOCAL0 = "LOCAL0"
    """


    """
    FACILITIES_LOCAL1 = "LOCAL1"
    """


    """
    FACILITIES_LOCAL2 = "LOCAL2"
    """


    """
    FACILITIES_LOCAL3 = "LOCAL3"
    """


    """
    FACILITIES_LOCAL4 = "LOCAL4"
    """


    """
    FACILITIES_LOCAL5 = "LOCAL5"
    """


    """
    FACILITIES_LOCAL6 = "LOCAL6"
    """


    """
    FACILITIES_LOCAL7 = "LOCAL7"
    """


    """
    LEVEL_EMERG = "EMERG"
    """


    """
    LEVEL_ALERT = "ALERT"
    """


    """
    LEVEL_CRIT = "CRIT"
    """


    """
    LEVEL_ERR = "ERR"
    """


    """
    LEVEL_WARNING = "WARNING"
    """


    """
    LEVEL_NOTICE = "NOTICE"
    """


    """
    LEVEL_INFO = "INFO"
    """


    """
    LEVEL_DEBUG = "DEBUG"
    """


    """
    PROTOCOL_TCP = "TCP"
    """


    """
    PROTOCOL_TLS = "TLS"
    """


    """
    PROTOCOL_UDP = "UDP"
    """


    """
    PROTOCOL_LI = "LI"
    """


    """
    PROTOCOL_LI_TLS = "LI-TLS"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'exporter_name': 'exporter_name',
                            'facilities': 'facilities',
                            'level': 'level',
                            'msgids': 'msgids',
                            'port': 'port',
                            'protocol': 'protocol',
                            'server': 'server',
                            'structured_data': 'structured_data',
                            'tls_ca_pem': 'tls_ca_pem',
                            'tls_cert_pem': 'tls_cert_pem',
                            'tls_client_ca_pem': 'tls_client_ca_pem',
                            'tls_key_pem': 'tls_key_pem',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 exporter_name=None,
                 facilities=None,
                 level=None,
                 msgids=None,
                 port=None,
                 protocol=None,
                 server=None,
                 structured_data=None,
                 tls_ca_pem=None,
                 tls_cert_pem=None,
                 tls_client_ca_pem=None,
                 tls_key_pem=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  exporter_name: :class:`str` or ``None``
        :param exporter_name: Syslog exporter name
        :type  facilities: :class:`list` of :class:`str` or ``None``
        :param facilities: Possible values are: 
            
            * :attr:`NodeSyslogExporterProperties.FACILITIES_KERN`
            * :attr:`NodeSyslogExporterProperties.FACILITIES_USER`
            * :attr:`NodeSyslogExporterProperties.FACILITIES_MAIL`
            * :attr:`NodeSyslogExporterProperties.FACILITIES_DAEMON`
            * :attr:`NodeSyslogExporterProperties.FACILITIES_AUTH`
            * :attr:`NodeSyslogExporterProperties.FACILITIES_SYSLOG`
            * :attr:`NodeSyslogExporterProperties.FACILITIES_LPR`
            * :attr:`NodeSyslogExporterProperties.FACILITIES_NEWS`
            * :attr:`NodeSyslogExporterProperties.FACILITIES_UUCP`
            * :attr:`NodeSyslogExporterProperties.FACILITIES_AUTHPRIV`
            * :attr:`NodeSyslogExporterProperties.FACILITIES_FTP`
            * :attr:`NodeSyslogExporterProperties.FACILITIES_LOGALERT`
            * :attr:`NodeSyslogExporterProperties.FACILITIES_CRON`
            * :attr:`NodeSyslogExporterProperties.FACILITIES_LOCAL0`
            * :attr:`NodeSyslogExporterProperties.FACILITIES_LOCAL1`
            * :attr:`NodeSyslogExporterProperties.FACILITIES_LOCAL2`
            * :attr:`NodeSyslogExporterProperties.FACILITIES_LOCAL3`
            * :attr:`NodeSyslogExporterProperties.FACILITIES_LOCAL4`
            * :attr:`NodeSyslogExporterProperties.FACILITIES_LOCAL5`
            * :attr:`NodeSyslogExporterProperties.FACILITIES_LOCAL6`
            * :attr:`NodeSyslogExporterProperties.FACILITIES_LOCAL7`
            
             Facilities to export
        :type  level: :class:`str` or ``None``
        :param level: Possible values are: 
            
            * :attr:`NodeSyslogExporterProperties.LEVEL_EMERG`
            * :attr:`NodeSyslogExporterProperties.LEVEL_ALERT`
            * :attr:`NodeSyslogExporterProperties.LEVEL_CRIT`
            * :attr:`NodeSyslogExporterProperties.LEVEL_ERR`
            * :attr:`NodeSyslogExporterProperties.LEVEL_WARNING`
            * :attr:`NodeSyslogExporterProperties.LEVEL_NOTICE`
            * :attr:`NodeSyslogExporterProperties.LEVEL_INFO`
            * :attr:`NodeSyslogExporterProperties.LEVEL_DEBUG`
            
             Logging level to export
        :type  msgids: :class:`list` of :class:`str` or ``None``
        :param msgids: MSGIDs to export
        :type  port: :class:`long` or ``None``
        :param port: Port to export to format: int64
        :type  protocol: :class:`str` or ``None``
        :param protocol: Possible values are: 
            
            * :attr:`NodeSyslogExporterProperties.PROTOCOL_TCP`
            * :attr:`NodeSyslogExporterProperties.PROTOCOL_TLS`
            * :attr:`NodeSyslogExporterProperties.PROTOCOL_UDP`
            * :attr:`NodeSyslogExporterProperties.PROTOCOL_LI`
            * :attr:`NodeSyslogExporterProperties.PROTOCOL_LI_TLS`
            
             Export protocol
        :type  server: :class:`str` or ``None``
        :param server: IP address or hostname of server to export to format:
            hostname-or-ipv4
        :type  structured_data: :class:`list` of :class:`str` or ``None``
        :param structured_data: Structured data to export
        :type  tls_ca_pem: :class:`str` or ``None``
        :param tls_ca_pem: CA certificate PEM of TLS server to export to
        :type  tls_cert_pem: :class:`str` or ``None``
        :param tls_cert_pem: Certificate PEM of the rsyslog client
        :type  tls_client_ca_pem: :class:`str` or ``None``
        :param tls_client_ca_pem: CA certificate PEM of the rsyslog client
        :type  tls_key_pem: :class:`str` or ``None``
        :param tls_key_pem: Private key PEM of the rsyslog client
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.exporter_name = exporter_name
        self.facilities = facilities
        self.level = level
        self.msgids = msgids
        self.port = port
        self.protocol = protocol
        self.server = server
        self.structured_data = structured_data
        self.tls_ca_pem = tls_ca_pem
        self.tls_cert_pem = tls_cert_pem
        self.tls_client_ca_pem = tls_client_ca_pem
        self.tls_key_pem = tls_key_pem
        VapiStruct.__init__(self)


NodeSyslogExporterProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.node_syslog_exporter_properties', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'exporter_name': type.OptionalType(type.StringType()),
        'facilities': type.OptionalType(type.ListType(type.StringType())),
        'level': type.OptionalType(type.StringType()),
        'msgids': type.OptionalType(type.ListType(type.StringType())),
        'port': type.OptionalType(type.IntegerType()),
        'protocol': type.OptionalType(type.StringType()),
        'server': type.OptionalType(type.StringType()),
        'structured_data': type.OptionalType(type.ListType(type.StringType())),
        'tls_ca_pem': type.OptionalType(type.StringType()),
        'tls_cert_pem': type.OptionalType(type.StringType()),
        'tls_client_ca_pem': type.OptionalType(type.StringType()),
        'tls_key_pem': type.OptionalType(type.StringType()),
    },
    NodeSyslogExporterProperties,
    False,
    None))



class NodeSyslogExporterPropertiesListResult(VapiStruct):
    """
    Node syslog exporter list results

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`NodeSyslogExporterProperties` or ``None``
        :param results: Node syslog exporter results
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


NodeSyslogExporterPropertiesListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.node_syslog_exporter_properties_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NodeSyslogExporterProperties'))),
    },
    NodeSyslogExporterPropertiesListResult,
    False,
    None))



class NodeTime(VapiStruct):
    """
    Node system time in UTC

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'system_datetime': 'system_datetime',
                            }

    def __init__(self,
                 system_datetime=None,
                ):
        """
        :type  system_datetime: :class:`str` or ``None``
        :param system_datetime: Datetime string in UTC
        """
        self.system_datetime = system_datetime
        VapiStruct.__init__(self)


NodeTime._set_binding_type(type.StructType(
    'com.vmware.nsx.model.node_time', {
        'system_datetime': type.OptionalType(type.StringType()),
    },
    NodeTime,
    False,
    None))



class NodeUserPasswordProperty(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'password': 'password',
                            }

    def __init__(self,
                 password=None,
                ):
        """
        :type  password: :class:`str` or ``None``
        :param password: The new password for user
        """
        self.password = password
        VapiStruct.__init__(self)


NodeUserPasswordProperty._set_binding_type(type.StructType(
    'com.vmware.nsx.model.node_user_password_property', {
        'password': type.OptionalType(type.StringType()),
    },
    NodeUserPasswordProperty,
    False,
    None))



class NodeUserProperties(VapiStruct):
    """
    Node user properties

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATUS_ACTIVE = "ACTIVE"
    """


    """
    STATUS_PASSWORD_EXPIRED = "PASSWORD_EXPIRED"
    """


    """
    STATUS_NOT_ACTIVATED = "NOT_ACTIVATED"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'full_name': 'full_name',
                            'last_password_change': 'last_password_change',
                            'old_password': 'old_password',
                            'password': 'password',
                            'password_change_frequency': 'password_change_frequency',
                            'status': 'status',
                            'userid': 'userid',
                            'username': 'username',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 full_name=None,
                 last_password_change=None,
                 old_password=None,
                 password=None,
                 password_change_frequency=None,
                 status=None,
                 userid=None,
                 username=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  full_name: :class:`str` or ``None``
        :param full_name: Full name for the user
        :type  last_password_change: :class:`long` or ``None``
        :param last_password_change: Number of days since password was last changed format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  old_password: :class:`str` or ``None``
        :param old_password: Old password for the user (required on PUT if password specified)
        :type  password: :class:`str` or ``None``
        :param password: Password for the user (optionally specified on PUT, unspecified on
            GET)
        :type  password_change_frequency: :class:`long` or ``None``
        :param password_change_frequency: Number of days password is valid before it must be changed. This
            can be set to 0 to indicate no password change is required or a
            positive integer up to 9999. By default local user passwords must
            be changed every 90 days. format: int64
        :type  status: :class:`str` or ``None``
        :param status: Possible values are: 
            
            * :attr:`NodeUserProperties.STATUS_ACTIVE`
            * :attr:`NodeUserProperties.STATUS_PASSWORD_EXPIRED`
            * :attr:`NodeUserProperties.STATUS_NOT_ACTIVATED`
            
            Status of the user. This value can be ACTIVE indicating
            authentication attempts will be successful if the correct
            credentials are specified. The value can also be PASSWORD_EXPIRED
            indicating authentication attempts will fail because the user's
            password has expired and must be changed. Or, this value can be
            NOT_ACTIVATED indicating the user's password has not yet been set
            and must be set before the user can authenticate.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  userid: :class:`long` or ``None``
        :param userid: Numeric id for the user format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  username: :class:`str` or ``None``
        :param username: User login name (must be \"root\" if userid is 0)
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.full_name = full_name
        self.last_password_change = last_password_change
        self.old_password = old_password
        self.password = password
        self.password_change_frequency = password_change_frequency
        self.status = status
        self.userid = userid
        self.username = username
        VapiStruct.__init__(self)


NodeUserProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.node_user_properties', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'full_name': type.OptionalType(type.StringType()),
        'last_password_change': type.OptionalType(type.IntegerType()),
        'old_password': type.OptionalType(type.StringType()),
        'password': type.OptionalType(type.StringType()),
        'password_change_frequency': type.OptionalType(type.IntegerType()),
        'status': type.OptionalType(type.StringType()),
        'userid': type.OptionalType(type.IntegerType()),
        'username': type.OptionalType(type.StringType()),
    },
    NodeUserProperties,
    False,
    None))



class NodeUserPropertiesListResult(VapiStruct):
    """
    Node users list results

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`NodeUserProperties` or ``None``
        :param results: List of node users
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


NodeUserPropertiesListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.node_user_properties_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NodeUserProperties'))),
    },
    NodeUserPropertiesListResult,
    False,
    None))



class NodeUserSettings(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'audit_password': 'audit_password',
                            'audit_username': 'audit_username',
                            'cli_password': 'cli_password',
                            'cli_username': 'cli_username',
                            'root_password': 'root_password',
                            }

    def __init__(self,
                 audit_password=None,
                 audit_username=None,
                 cli_password=None,
                 cli_username=None,
                 root_password=None,
                ):
        """
        :type  audit_password: :class:`str` or ``None``
        :param audit_password: Password for the node audit user. For deployment, this property is
            required. After deployment, this property is ignored, and the node
            cli must be used to change the password. The password specified
            must be at least 12 characters in length and must contain at least
            one lowercase, one uppercase, one numeric character and one special
            character (except quotes). Passwords based on dictionary words and
            palindromes are invalid.
        :type  audit_username: :class:`str` or ``None``
        :param audit_username: The default username is \"audit\". To configure username, you must
            provide this property together with **audit_password**. Username
            must contain ASCII characters only.
        :type  cli_password: :class:`str` or ``None``
        :param cli_password: Password for the node cli user. For deployment, this property is
            required. After deployment, this property is ignored, and the node
            cli must be used to change the password. The password specified
            must be at least 12 characters in length and must contain at least
            one lowercase, one uppercase, one numeric character and one special
            character (except quotes). Passwords based on dictionary words and
            palindromes are invalid.
        :type  cli_username: :class:`str` or ``None``
        :param cli_username: To configure username, you must provide this property together with
            **cli_password**. Username must contain ASCII characters only.
        :type  root_password: :class:`str` or ``None``
        :param root_password: Password for the node root user. For deployment, this property is
            required. After deployment, this property is ignored, and the node
            cli must be used to change the password. The password specified
            must be at least 12 characters in length and must contain at least
            one lowercase, one uppercase, one numeric character and one special
            character (except quotes). Passwords based on dictionary words and
            palindromes are invalid.
        """
        self.audit_password = audit_password
        self.audit_username = audit_username
        self.cli_password = cli_password
        self.cli_username = cli_username
        self.root_password = root_password
        VapiStruct.__init__(self)


NodeUserSettings._set_binding_type(type.StructType(
    'com.vmware.nsx.model.node_user_settings', {
        'audit_password': type.OptionalType(type.StringType()),
        'audit_username': type.OptionalType(type.StringType()),
        'cli_password': type.OptionalType(type.StringType()),
        'cli_username': type.OptionalType(type.StringType()),
        'root_password': type.OptionalType(type.StringType()),
    },
    NodeUserSettings,
    False,
    None))



class NodeVersion(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'node_version': 'node_version',
                            'product_version': 'product_version',
                            }

    def __init__(self,
                 node_version=None,
                 product_version=None,
                ):
        """
        :type  node_version: :class:`str` or ``None``
        :param node_version: Node version
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  product_version: :class:`str` or ``None``
        :param product_version: Product version
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.node_version = node_version
        self.product_version = product_version
        VapiStruct.__init__(self)


NodeVersion._set_binding_type(type.StructType(
    'com.vmware.nsx.model.node_version', {
        'node_version': type.OptionalType(type.StringType()),
        'product_version': type.OptionalType(type.StringType()),
    },
    NodeVersion,
    False,
    None))



class NormalizedResourceListResult(VapiStruct):
    """
    Paged Collection of normalized resources

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`ResourceReference` or ``None``
        :param results: Normalized resource list results
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


NormalizedResourceListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.normalized_resource_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceReference'))),
    },
    NormalizedResourceListResult,
    False,
    None))



class Notification(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'notification_id': 'notification_id',
                            'uri_filters': 'uri_filters',
                            }

    def __init__(self,
                 notification_id=None,
                 uri_filters=None,
                ):
        """
        :type  notification_id: :class:`str` or ``None``
        :param notification_id: A string identifying feature_name.notification_name to indicate a
            notification watcher is interested in receiving notifications for
            the URI identified by the feature_name.notification_name.
        :type  uri_filters: :class:`list` of :class:`str` or ``None``
        :param uri_filters: Optional list of URIs
        """
        self.notification_id = notification_id
        self.uri_filters = uri_filters
        VapiStruct.__init__(self)


Notification._set_binding_type(type.StructType(
    'com.vmware.nsx.model.notification', {
        'notification_id': type.OptionalType(type.StringType()),
        'uri_filters': type.OptionalType(type.ListType(type.StringType())),
    },
    Notification,
    False,
    None))



class NotificationAuthenticationScheme(VapiStruct):
    """
    NotificationAuthenticationScheme describes how notification requests should
    authenticate to the server.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    SCHEME_NAME_BASIC_AUTH = "BASIC_AUTH"
    """


    """
    SCHEME_NAME_CERTIFICATE = "CERTIFICATE"
    """


    """



    _canonical_to_pep_names = {
                            'certificate_id': 'certificate_id',
                            'password': 'password',
                            'scheme_name': 'scheme_name',
                            'username': 'username',
                            }

    def __init__(self,
                 certificate_id=None,
                 password=None,
                 scheme_name=None,
                 username=None,
                ):
        """
        :type  certificate_id: :class:`str` or ``None``
        :param certificate_id: Certificate ID with a valid certificate and private key, procured
            from trust-management API.
        :type  password: :class:`str` or ``None``
        :param password: Password to use if scheme_name is BASIC_AUTH.
        :type  scheme_name: :class:`str` or ``None``
        :param scheme_name: Possible values are: 
            
            * :attr:`NotificationAuthenticationScheme.SCHEME_NAME_BASIC_AUTH`
            * :attr:`NotificationAuthenticationScheme.SCHEME_NAME_CERTIFICATE`
            
            Authentication scheme to use when making notification requests to
            the partner/customer specified watcher. Specify one of BASIC_AUTH
            or CERTIFICATE.
        :type  username: :class:`str` or ``None``
        :param username: Username to use if scheme_name is BASIC_AUTH.
        """
        self.certificate_id = certificate_id
        self.password = password
        self.scheme_name = scheme_name
        self.username = username
        VapiStruct.__init__(self)


NotificationAuthenticationScheme._set_binding_type(type.StructType(
    'com.vmware.nsx.model.notification_authentication_scheme', {
        'certificate_id': type.OptionalType(type.StringType()),
        'password': type.OptionalType(type.StringType()),
        'scheme_name': type.OptionalType(type.StringType()),
        'username': type.OptionalType(type.StringType()),
    },
    NotificationAuthenticationScheme,
    False,
    None))



class NotificationWatcher(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    METHOD_POST = "POST"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'authentication_scheme': 'authentication_scheme',
                            'certificate_sha256_thumbprint': 'certificate_sha256_thumbprint',
                            'max_send_uri_count': 'max_send_uri_count',
                            'method': 'method',
                            'port': 'port',
                            'send_interval': 'send_interval',
                            'send_timeout': 'send_timeout',
                            'server': 'server',
                            'uri': 'uri',
                            'use_https': 'use_https',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 authentication_scheme=None,
                 certificate_sha256_thumbprint=None,
                 max_send_uri_count=None,
                 method=None,
                 port=None,
                 send_interval=None,
                 send_timeout=None,
                 server=None,
                 uri=None,
                 use_https=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Optional description that can be associated with this
            NotificationWatcher.
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: System generated identifier to identify a notification watcher
            uniquely.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  authentication_scheme: :class:`NotificationAuthenticationScheme` or ``None``
        :param authentication_scheme: A NotificationAuthenticationScheme that describes how notification
            requests should authenticate to the server.
        :type  certificate_sha256_thumbprint: :class:`str` or ``None``
        :param certificate_sha256_thumbprint: Contains the hex-encoded SHA256 thumbprint of the HTTPS
            certificate. It must be specified if use_https is set to true.
        :type  max_send_uri_count: :class:`long` or ``None``
        :param max_send_uri_count: If the number of notification URIs accumulated in specified
            send_interval exceeds max_send_uri_count, then multiple
            notification requests (each with max_send_uri_count or less number
            of notification URIs) will be sent to this NotificationWatcher. The
            default value is 5000. format: int64
        :type  method: :class:`str` or ``None``
        :param method: Possible values are: 
            
            * :attr:`NotificationWatcher.METHOD_POST`
            
            Type of method notification requests should be made on the
            specified server. The value must be set to POST.
        :type  port: :class:`long` or ``None``
        :param port: Optional integer port value to specify a non-standard HTTP or HTTPS
            port. format: int64
        :type  send_interval: :class:`long` or ``None``
        :param send_interval: Optional time interval (in seconds) for which notification URIs
            will be accumulated. At the end of the time interval the
            accumulated notification URIs will be sent to this
            NotificationWatcher in the form of zero (nothing accumulated) or
            more notification requests as soon as possible. If it is not
            specified, the NotificationWatcher should expected to receive
            notifications at any time. format: int64
        :type  send_timeout: :class:`long` or ``None``
        :param send_timeout: Optional time duration (in seconds) to specify request timeout to
            notification watcher. If the send reaches the timeout, will try to
            send refresh_needed as true in the next time interval. The default
            value is 30 seconds. format: int64
        :type  server: :class:`str` or ``None``
        :param server: IP address or fully qualified domain name of the partner/customer
            watcher.
        :type  uri: :class:`str` or ``None``
        :param uri: URI notification requests should be made on the specified server.
        :type  use_https: :class:`bool` or ``None``
        :param use_https: Optional field, when set to true indicates REST API server should
            use HTTPS.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.authentication_scheme = authentication_scheme
        self.certificate_sha256_thumbprint = certificate_sha256_thumbprint
        self.max_send_uri_count = max_send_uri_count
        self.method = method
        self.port = port
        self.send_interval = send_interval
        self.send_timeout = send_timeout
        self.server = server
        self.uri = uri
        self.use_https = use_https
        VapiStruct.__init__(self)


NotificationWatcher._set_binding_type(type.StructType(
    'com.vmware.nsx.model.notification_watcher', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'authentication_scheme': type.OptionalType(type.ReferenceType(__name__, 'NotificationAuthenticationScheme')),
        'certificate_sha256_thumbprint': type.OptionalType(type.StringType()),
        'max_send_uri_count': type.OptionalType(type.IntegerType()),
        'method': type.OptionalType(type.StringType()),
        'port': type.OptionalType(type.IntegerType()),
        'send_interval': type.OptionalType(type.IntegerType()),
        'send_timeout': type.OptionalType(type.IntegerType()),
        'server': type.OptionalType(type.StringType()),
        'uri': type.OptionalType(type.StringType()),
        'use_https': type.OptionalType(type.BooleanType()),
    },
    NotificationWatcher,
    False,
    None))



class NotificationWatcherListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`NotificationWatcher` or ``None``
        :param results: List of notification watchers
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


NotificationWatcherListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.notification_watcher_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NotificationWatcher'))),
    },
    NotificationWatcherListResult,
    False,
    None))



class NotificationsList(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'notifications': 'notifications',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 notifications=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  notifications: :class:`list` of :class:`Notification` or ``None``
        :param notifications: 
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.notifications = notifications
        VapiStruct.__init__(self)


NotificationsList._set_binding_type(type.StructType(
    'com.vmware.nsx.model.notifications_list', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'notifications': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Notification'))),
    },
    NotificationsList,
    False,
    None))



class NsxRole(VapiStruct):
    """
    Role

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    PERMISSIONS_READ_API = "read-api"
    """


    """
    PERMISSIONS_READ_WRITE_API = "read-write-api"
    """


    """
    PERMISSIONS_CRUD = "crud"
    """


    """
    PERMISSIONS_READ = "read"
    """


    """
    PERMISSIONS_EXECUTE = "execute"
    """


    """
    PERMISSIONS_NONE = "none"
    """


    """



    _canonical_to_pep_names = {
                            'permissions': 'permissions',
                            'role': 'role',
                            }

    def __init__(self,
                 permissions=None,
                 role=None,
                ):
        """
        :type  permissions: :class:`list` of :class:`str` or ``None``
        :param permissions: Possible values are: 
            
            * :attr:`NsxRole.PERMISSIONS_READ_API`
            * :attr:`NsxRole.PERMISSIONS_READ_WRITE_API`
            * :attr:`NsxRole.PERMISSIONS_CRUD`
            * :attr:`NsxRole.PERMISSIONS_READ`
            * :attr:`NsxRole.PERMISSIONS_EXECUTE`
            * :attr:`NsxRole.PERMISSIONS_NONE`
            
            Please use the /user-info/permissions api to get the permission
            that the user has on each feature.
        :type  role: :class:`str` or ``None``
        :param role: This field represents the identifier of the role. With the
            introduction of custom roles, this field is no longer an enum.
        """
        self.permissions = permissions
        self.role = role
        VapiStruct.__init__(self)


NsxRole._set_binding_type(type.StructType(
    'com.vmware.nsx.model.nsx_role', {
        'permissions': type.OptionalType(type.ListType(type.StringType())),
        'role': type.OptionalType(type.StringType()),
    },
    NsxRole,
    False,
    None))



class NtpProperties(VapiStruct):
    """
    This object contains the list of NTP servers used by NSX nodes.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'servers': 'servers',
                            }

    def __init__(self,
                 servers=None,
                ):
        """
        :type  servers: :class:`list` of :class:`str` or ``None``
        :param servers: List of NTP servers. format: hostname-or-ipv4
        """
        self.servers = servers
        VapiStruct.__init__(self)


NtpProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.ntp_properties', {
        'servers': type.OptionalType(type.ListType(type.StringType())),
    },
    NtpProperties,
    False,
    None))



class NtpServiceProperties(VapiStruct):
    """
    NTP Service properties

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'servers': 'servers',
                            'start_on_boot': 'start_on_boot',
                            }

    def __init__(self,
                 servers=None,
                 start_on_boot=None,
                ):
        """
        :type  servers: :class:`list` of :class:`str` or ``None``
        :param servers: NTP servers format: hostname-or-ipv4
        :type  start_on_boot: :class:`bool` or ``None``
        :param start_on_boot: Start NTP service when system boots
        """
        self.servers = servers
        self.start_on_boot = start_on_boot
        VapiStruct.__init__(self)


NtpServiceProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.ntp_service_properties', {
        'servers': type.OptionalType(type.ListType(type.StringType())),
        'start_on_boot': type.OptionalType(type.BooleanType()),
    },
    NtpServiceProperties,
    False,
    None))



class NvdsUpgradeConfigIssue(VapiStruct):
    """
    Issues reported by upgrade readiness check

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'component': 'component',
                            'error': 'error',
                            'id': 'id',
                            'recommendation': 'recommendation',
                            }

    def __init__(self,
                 component=None,
                 error=None,
                 id=None,
                 recommendation=None,
                ):
        """
        :type  component: :class:`str` or ``None``
        :param component: Name of the component/object
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  error: :class:`str` or ``None``
        :param error: Error for the component describing precheck failure
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  id: :class:`str` or ``None``
        :param id: Id of the object that generated error
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  recommendation: :class:`str` or ``None``
        :param recommendation: Recommendation to resolve the error returned for component
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.component = component
        self.error = error
        self.id = id
        self.recommendation = recommendation
        VapiStruct.__init__(self)


NvdsUpgradeConfigIssue._set_binding_type(type.StructType(
    'com.vmware.nsx.model.nvds_upgrade_config_issue', {
        'component': type.OptionalType(type.StringType()),
        'error': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'recommendation': type.OptionalType(type.StringType()),
    },
    NvdsUpgradeConfigIssue,
    False,
    None))



class NvdsUpgradeHostState(VapiStruct):
    """
    Individual host upgrade state

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    OVERALL_STATE_UPGRADE_READY = "UPGRADE_READY"
    """


    """
    OVERALL_STATE_UPGRADE_IN_PROGRESS = "UPGRADE_IN_PROGRESS"
    """


    """
    OVERALL_STATE_UPGRADE_FAILED = "UPGRADE_FAILED"
    """


    """
    OVERALL_STATE_SUCCESS = "SUCCESS"
    """


    """



    _canonical_to_pep_names = {
                            'host': 'host',
                            'overall_state': 'overall_state',
                            'state_details': 'state_details',
                            'upgrade_stage': 'upgrade_stage',
                            }

    def __init__(self,
                 host=None,
                 overall_state=None,
                 state_details=None,
                 upgrade_stage=None,
                ):
        """
        :type  host: :class:`str` or ``None``
        :param host: TransportNode identifier
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  overall_state: :class:`str` or ``None``
        :param overall_state: Possible values are: 
            
            * :attr:`NvdsUpgradeHostState.OVERALL_STATE_UPGRADE_READY`
            * :attr:`NvdsUpgradeHostState.OVERALL_STATE_UPGRADE_IN_PROGRESS`
            * :attr:`NvdsUpgradeHostState.OVERALL_STATE_UPGRADE_FAILED`
            * :attr:`NvdsUpgradeHostState.OVERALL_STATE_SUCCESS`
            
             Overall state of N-VDSes on the TransportNodes
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  state_details: :class:`list` of :class:`str` or ``None``
        :param state_details: Details of the N-VDS upgrade state on the host
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  upgrade_stage: :class:`str` or ``None``
        :param upgrade_stage: This field returns current stage of Migration task. Here is a
            sequence of stages the task cycles through, RETRIEVE_SAVED_CONFIG,
            TN_VALIDATE, TN_STATELESS_WAIT_FOR_HP, DETACH_TNP, TNP_WAIT,
            TN_SEND_HS_MIGRATION_MSG, TN_ADD_HOST_TO_VDS, TN_UPDATE,
            TN_UPDATE_WAIT, TN_DELETE, TN_DELETE_WAIT, FN_DELETE_WAIT,
            TN_RECONFIG_HOST, TN_CREATE, TN_CREATE_WAIT, UPDATE_TNP_AND_APPLY,
            TN_EXIT_MM, TN_MIGRATION_COMPLETED Depending on the type of host
            (stateful, stateless, Sddc, etc.) migration task may not cycle
            through all stages but in will follow above sequence. If stage is
            TN_MIGRATION_COMPLETED refer to field overall_state for SUCCESS or
            UPGRADE_FAILURE and state_details for details on same.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.host = host
        self.overall_state = overall_state
        self.state_details = state_details
        self.upgrade_stage = upgrade_stage
        VapiStruct.__init__(self)


NvdsUpgradeHostState._set_binding_type(type.StructType(
    'com.vmware.nsx.model.nvds_upgrade_host_state', {
        'host': type.OptionalType(type.StringType()),
        'overall_state': type.OptionalType(type.StringType()),
        'state_details': type.OptionalType(type.ListType(type.StringType())),
        'upgrade_stage': type.OptionalType(type.StringType()),
    },
    NvdsUpgradeHostState,
    False,
    None))



class NvdsUpgradePrecheckId(VapiStruct):
    """
    Nvds upgrade precheck ID

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'precheck_id': 'precheck_id',
                            }

    def __init__(self,
                 precheck_id=None,
                ):
        """
        :type  precheck_id: :class:`str` or ``None``
        :param precheck_id: Tracking ID of nvds upgrade precheck
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.precheck_id = precheck_id
        VapiStruct.__init__(self)


NvdsUpgradePrecheckId._set_binding_type(type.StructType(
    'com.vmware.nsx.model.nvds_upgrade_precheck_id', {
        'precheck_id': type.OptionalType(type.StringType()),
    },
    NvdsUpgradePrecheckId,
    False,
    None))



class NvdsUpgradeStatusSummary(VapiStruct):
    """
    Overall status of the upgrade readiness check

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    PRECHECK_STATUS_IN_PROGRESS = "IN_PROGRESS"
    """


    """
    PRECHECK_STATUS_FAILED = "FAILED"
    """


    """
    PRECHECK_STATUS_PENDING_TOPOLOGY = "PENDING_TOPOLOGY"
    """


    """
    PRECHECK_STATUS_APPLYING_TOPOLOGY = "APPLYING_TOPOLOGY"
    """


    """
    PRECHECK_STATUS_APPLY_TOPOLOGY_FAILED = "APPLY_TOPOLOGY_FAILED"
    """


    """
    PRECHECK_STATUS_READY = "READY"
    """


    """



    _canonical_to_pep_names = {
                            'migration_state': 'migration_state',
                            'precheck_id': 'precheck_id',
                            'precheck_issue': 'precheck_issue',
                            'precheck_status': 'precheck_status',
                            }

    def __init__(self,
                 migration_state=None,
                 precheck_id=None,
                 precheck_issue=None,
                 precheck_status=None,
                ):
        """
        :type  migration_state: :class:`list` of :class:`NvdsUpgradeHostState` or ``None``
        :param migration_state: Overall state of migration across all TransportNodes
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  precheck_id: :class:`str` or ``None``
        :param precheck_id: Tracking ID of nvds upgrade precheck
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  precheck_issue: :class:`list` of :class:`NvdsUpgradeConfigIssue` or ``None``
        :param precheck_issue: Config issue in pre-check
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  precheck_status: :class:`str` or ``None``
        :param precheck_status: Possible values are: 
            
            * :attr:`NvdsUpgradeStatusSummary.PRECHECK_STATUS_IN_PROGRESS`
            * :attr:`NvdsUpgradeStatusSummary.PRECHECK_STATUS_FAILED`
            * :attr:`NvdsUpgradeStatusSummary.PRECHECK_STATUS_PENDING_TOPOLOGY`
            *
              :attr:`NvdsUpgradeStatusSummary.PRECHECK_STATUS_APPLYING_TOPOLOGY`
            *
              :attr:`NvdsUpgradeStatusSummary.PRECHECK_STATUS_APPLY_TOPOLOGY_FAILED`
            * :attr:`NvdsUpgradeStatusSummary.PRECHECK_STATUS_READY`
            
             Overall status of pre-check
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.migration_state = migration_state
        self.precheck_id = precheck_id
        self.precheck_issue = precheck_issue
        self.precheck_status = precheck_status
        VapiStruct.__init__(self)


NvdsUpgradeStatusSummary._set_binding_type(type.StructType(
    'com.vmware.nsx.model.nvds_upgrade_status_summary', {
        'migration_state': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NvdsUpgradeHostState'))),
        'precheck_id': type.OptionalType(type.StringType()),
        'precheck_issue': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NvdsUpgradeConfigIssue'))),
        'precheck_status': type.OptionalType(type.StringType()),
    },
    NvdsUpgradeStatusSummary,
    False,
    None))



class NvdsUpgradeTopology(VapiStruct):
    """
    NVDS to VDS mappings for migration

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'compute_manager_topology': 'compute_manager_topology',
                            'nvds_id': 'nvds_id',
                            'nvds_name': 'nvds_name',
                            }

    def __init__(self,
                 compute_manager_topology=None,
                 nvds_id=None,
                 nvds_name=None,
                ):
        """
        :type  compute_manager_topology: :class:`list` of :class:`ComputeManagerTopology` or ``None``
        :param compute_manager_topology: All resultant VDS mapping for a NVDS after the migration
        :type  nvds_id: :class:`str` or ``None``
        :param nvds_id: Identifier for a NVDS
        :type  nvds_name: :class:`str` or ``None``
        :param nvds_name: Name of a NVDS
        """
        self.compute_manager_topology = compute_manager_topology
        self.nvds_id = nvds_id
        self.nvds_name = nvds_name
        VapiStruct.__init__(self)


NvdsUpgradeTopology._set_binding_type(type.StructType(
    'com.vmware.nsx.model.nvds_upgrade_topology', {
        'compute_manager_topology': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ComputeManagerTopology'))),
        'nvds_id': type.OptionalType(type.StringType()),
        'nvds_name': type.OptionalType(type.StringType()),
    },
    NvdsUpgradeTopology,
    False,
    None))



class Oauth2Credentials(VapiStruct):
    """
    Oauth2 Account Credentials

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'client_id': 'client_id',
                            'client_secret': 'client_secret',
                            }

    def __init__(self,
                 client_id=None,
                 client_secret=None,
                ):
        """
        :type  client_id: :class:`str` or ``None``
        :param client_id: Client ID, that will be used for authentication in AWS environment,
        :type  client_secret: :class:`str` or ``None``
        :param client_secret: Client secret, that will be used for authentication in AWS
            environment. Can be some passphrase.
        """
        self.client_id = client_id
        self.client_secret = client_secret
        VapiStruct.__init__(self)


Oauth2Credentials._set_binding_type(type.StructType(
    'com.vmware.nsx.model.oauth2_credentials', {
        'client_id': type.OptionalType(type.StringType()),
        'client_secret': type.OptionalType(type.StringType()),
    },
    Oauth2Credentials,
    False,
    None))



class OidcEndPoint(VapiStruct):
    """
    OpenID Connect end-point specifying where to fetch the JWKS document used
    to validate JWT tokens for TokenBasedPrincipalIdentities.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'issuer': 'issuer',
                            'jwks_uri': 'jwks_uri',
                            'oidc_type': 'oidc_type',
                            'oidc_uri': 'oidc_uri',
                            'thumbprint': 'thumbprint',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 issuer=None,
                 jwks_uri=None,
                 oidc_type=None,
                 oidc_uri=None,
                 thumbprint=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  issuer: :class:`str` or ``None``
        :param issuer: Issuer of the JWT tokens for the given type. This field is fetched
            from the meta-data located at the oidc_uri.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  jwks_uri: :class:`str` or ``None``
        :param jwks_uri: The URI where the JWKS document is located that has the key used to
            validate the JWT signature.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  oidc_type: :class:`str` or ``None``
        :param oidc_type: Type used to distinguish the OIDC end-points by IDP.
        :type  oidc_uri: :class:`str` or ``None``
        :param oidc_uri: URI of the OpenID Connect end-point.
        :type  thumbprint: :class:`str` or ``None``
        :param thumbprint: Thumbprint in SHA-256 format used to verify the server certificate
            at the URI.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.issuer = issuer
        self.jwks_uri = jwks_uri
        self.oidc_type = oidc_type
        self.oidc_uri = oidc_uri
        self.thumbprint = thumbprint
        VapiStruct.__init__(self)


OidcEndPoint._set_binding_type(type.StructType(
    'com.vmware.nsx.model.oidc_end_point', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'issuer': type.OptionalType(type.StringType()),
        'jwks_uri': type.OptionalType(type.StringType()),
        'oidc_type': type.OptionalType(type.StringType()),
        'oidc_uri': type.OptionalType(type.StringType()),
        'thumbprint': type.OptionalType(type.StringType()),
    },
    OidcEndPoint,
    False,
    None))



class OidcEndPointListResult(VapiStruct):
    """
    OidcEndPoint query result

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`OidcEndPoint` or ``None``
        :param results: OidcEndPoint list.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


OidcEndPointListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.oidc_end_point_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'OidcEndPoint'))),
    },
    OidcEndPointListResult,
    False,
    None))



class OperationCollector(VapiStruct):
    """
    The operation collector is defined to receive stats from hosts. (eg.
    vRNI-collector collects all the system metrics)

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    COLLECTOR_TYPE_VRNI = "VRNI"
    """


    """
    COLLECTOR_TYPE_WAVE_FRONT = "WAVE_FRONT"
    """


    """



    _canonical_to_pep_names = {
                            'collector_ip': 'collector_ip',
                            'collector_port': 'collector_port',
                            'collector_type': 'collector_type',
                            }

    def __init__(self,
                 collector_ip=None,
                 collector_port=None,
                 collector_type=None,
                ):
        """
        :type  collector_ip: :class:`str` or ``None``
        :param collector_ip: IP address for the operation collector. format: ip
        :type  collector_port: :class:`long` or ``None``
        :param collector_port: Port for the operation collector. format: int32
        :type  collector_type: :class:`str` or ``None``
        :param collector_type: Possible values are: 
            
            * :attr:`OperationCollector.COLLECTOR_TYPE_VRNI`
            * :attr:`OperationCollector.COLLECTOR_TYPE_WAVE_FRONT`
            
             Define the operation collector type.
        """
        self.collector_ip = collector_ip
        self.collector_port = collector_port
        self.collector_type = collector_type
        VapiStruct.__init__(self)


OperationCollector._set_binding_type(type.StructType(
    'com.vmware.nsx.model.operation_collector', {
        'collector_ip': type.OptionalType(type.StringType()),
        'collector_port': type.OptionalType(type.IntegerType()),
        'collector_type': type.OptionalType(type.StringType()),
    },
    OperationCollector,
    False,
    None))



class OperationCollectorGlobalConfig(VapiStruct):
    """
    NSX global configs for operation collector

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "OperationCollectorGlobalConfig"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'collectors': 'collectors',
                            'report_interval': 'report_interval',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            }

    def __init__(self,
                 collectors=None,
                 report_interval=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='OperationCollectorGlobalConfig',
                 tags=None,
                ):
        """
        :type  collectors: :class:`list` of :class:`OperationCollector` or ``None``
        :param collectors: Operation Collector Config.
        :type  report_interval: :class:`long` or ``None``
        :param report_interval: Report interval for operation data in seconds. format: int32
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`GlobalConfigs.RESOURCE_TYPE_SWITCHINGGLOBALCONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_ROUTINGGLOBALCONFIG`
            *
              :attr:`GlobalConfigs.RESOURCE_TYPE_OPERATIONCOLLECTORGLOBALCONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_FIREWALLGLOBALCONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_ESXGLOBALOPAQUECONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_SECURITYGLOBALCONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_FIPSGLOBALCONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_FEDERATIONGLOBALCONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_IDSGLOBALCONFIG`
            
             Valid Global configuration types
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        """
        self.collectors = collectors
        self.report_interval = report_interval
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

OperationCollectorGlobalConfig._set_binding_type(type.StructType(
    'com.vmware.nsx.model.operation_collector_global_config', {
        'collectors': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'OperationCollector'))),
        'report_interval': type.OptionalType(type.IntegerType()),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
    },
    OperationCollectorGlobalConfig,
    False,
    None))



class OrgInfo(VapiStruct):
    """
    Organization ID and role, predefined for a particular type of VMware
    support.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'org_id': 'org_id',
                            'org_role': 'org_role',
                            }

    def __init__(self,
                 org_id=None,
                 org_role=None,
                ):
        """
        :type  org_id: :class:`str` or ``None``
        :param org_id: Organization ID, connected to a predefined role of a VMware
            support.
        :type  org_role: :class:`str` or ``None``
        :param org_role: Predefined role of a VMware support.
        """
        self.org_id = org_id
        self.org_role = org_role
        VapiStruct.__init__(self)


OrgInfo._set_binding_type(type.StructType(
    'com.vmware.nsx.model.org_info', {
        'org_id': type.OptionalType(type.StringType()),
        'org_role': type.OptionalType(type.StringType()),
    },
    OrgInfo,
    False,
    None))



class OvfInfo(VapiStruct):
    """
    Information related to OVF file.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'ovf_name': 'ovf_name',
                            'version': 'version',
                            }

    def __init__(self,
                 ovf_name=None,
                 version=None,
                ):
        """
        :type  ovf_name: :class:`str` or ``None``
        :param ovf_name: Name of OVF file.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  version: :class:`str` or ``None``
        :param version: Version of the OVF.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.ovf_name = ovf_name
        self.version = version
        VapiStruct.__init__(self)


OvfInfo._set_binding_type(type.StructType(
    'com.vmware.nsx.model.ovf_info', {
        'ovf_name': type.OptionalType(type.StringType()),
        'version': type.OptionalType(type.StringType()),
    },
    OvfInfo,
    False,
    None))



class OwnerResourceLink(VapiStruct):
    """
    The server will populate this field when returing the resource. Ignored on
    PUT and POST.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'action': 'action',
                            'href': 'href',
                            'rel': 'rel',
                            }

    def __init__(self,
                 action=None,
                 href=None,
                 rel=None,
                ):
        """
        :type  action: :class:`str` or ``None``
        :param action: Optional action
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  href: :class:`str` or ``None``
        :param href: Link to resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  rel: :class:`str` or ``None``
        :param rel: Custom relation type (follows RFC 5988 where appropriate
            definitions exist)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.action = action
        self.href = href
        self.rel = rel
        VapiStruct.__init__(self)


OwnerResourceLink._set_binding_type(type.StructType(
    'com.vmware.nsx.model.owner_resource_link', {
        'action': type.OptionalType(type.StringType()),
        'href': type.OptionalType(type.StringType()),
        'rel': type.OptionalType(type.StringType()),
    },
    OwnerResourceLink,
    False,
    None))



class PBRRule(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    ACTION_TO_UNDERLAY_NAT = "ROUTE_TO_UNDERLAY_NAT"
    """


    """
    ACTION_TO_OVERLAY_NAT = "ROUTE_TO_OVERLAY_NAT"
    """


    """
    ACTION_TO_UNDERLAY = "ROUTE_TO_UNDERLAY"
    """


    """
    ACTION_TO_OVERLAY = "ROUTE_TO_OVERLAY"
    """


    """
    ACTION_FROM_OVERLAY = "ROUTE_FROM_OVERLAY"
    """


    """
    ACTION_FROM_UNDERLAY = "ROUTE_FROM_UNDERLAY"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_owner': 'owner',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'action': 'action',
                            'applied_tos': 'applied_tos',
                            'destinations': 'destinations',
                            'disabled': 'disabled',
                            'logged': 'logged',
                            'notes': 'notes',
                            'rule_tag': 'rule_tag',
                            'services': 'services',
                            'sources': 'sources',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 owner=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 action=None,
                 applied_tos=None,
                 destinations=None,
                 disabled=None,
                 logged=None,
                 notes=None,
                 rule_tag=None,
                 services=None,
                 sources=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  owner: :class:`OwnerResourceLink` or ``None``
        :param owner: Owner of this resource
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Identifier of the resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  action: :class:`str` or ``None``
        :param action: Possible values are: 
            
            * :attr:`PBRRule.ACTION_TO_UNDERLAY_NAT`
            * :attr:`PBRRule.ACTION_TO_OVERLAY_NAT`
            * :attr:`PBRRule.ACTION_TO_UNDERLAY`
            * :attr:`PBRRule.ACTION_TO_OVERLAY`
            * :attr:`PBRRule.ACTION_FROM_OVERLAY`
            * :attr:`PBRRule.ACTION_FROM_UNDERLAY`
            
             Action enforced on the packets which matches the PBR rule.
        :type  applied_tos: :class:`list` of :class:`ResourceReference` or ``None``
        :param applied_tos: List of object where rule will be enforced. field overrides this
            one. Null will be treated as any.
        :type  destinations: :class:`list` of :class:`ResourceReference` or ``None``
        :param destinations: List of the destinations. Null will be treated as any.
        :type  disabled: :class:`bool` or ``None``
        :param disabled: Flag to disable rule. Disabled will only be persisted but never
            provisioned/realized.
        :type  logged: :class:`bool` or ``None``
        :param logged: Flag to enable packet logging. Default is disabled.
        :type  notes: :class:`str` or ``None``
        :param notes: User notes specific to the rule.
        :type  rule_tag: :class:`str` or ``None``
        :param rule_tag: User level field which will be printed in CLI and packet logs.
        :type  services: :class:`list` of :class:`PBRService` or ``None``
        :param services: List of the services. Null will be treated as any.
        :type  sources: :class:`list` of :class:`ResourceReference` or ``None``
        :param sources: List of sources. Null will be treated as any.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.owner = owner
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.action = action
        self.applied_tos = applied_tos
        self.destinations = destinations
        self.disabled = disabled
        self.logged = logged
        self.notes = notes
        self.rule_tag = rule_tag
        self.services = services
        self.sources = sources
        VapiStruct.__init__(self)


PBRRule._set_binding_type(type.StructType(
    'com.vmware.nsx.model.PBR_rule', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_owner': type.OptionalType(type.ReferenceType(__name__, 'OwnerResourceLink')),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'action': type.OptionalType(type.StringType()),
        'applied_tos': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceReference'))),
        'destinations': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceReference'))),
        'disabled': type.OptionalType(type.BooleanType()),
        'logged': type.OptionalType(type.BooleanType()),
        'notes': type.OptionalType(type.StringType()),
        'rule_tag': type.OptionalType(type.StringType()),
        'services': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'PBRService'))),
        'sources': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceReference'))),
    },
    PBRRule,
    False,
    None))



class PBRRuleList(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'rules': 'rules',
                            }

    def __init__(self,
                 rules=None,
                ):
        """
        :type  rules: :class:`list` of :class:`PBRRule` or ``None``
        :param rules: List of PBR rules in the section.
        """
        self.rules = rules
        VapiStruct.__init__(self)


PBRRuleList._set_binding_type(type.StructType(
    'com.vmware.nsx.model.PBR_rule_list', {
        'rules': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'PBRRule'))),
    },
    PBRRuleList,
    False,
    None))



class PBRRuleListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`PBRRule` or ``None``
        :param results: PBR rule list result with pagination support.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


PBRRuleListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.PBR_rule_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'PBRRule'))),
    },
    PBRRuleListResult,
    False,
    None))



class PBRSection(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'rule_count': 'rule_count',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 rule_count=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  rule_count: :class:`long` or ``None``
        :param rule_count: Number of rules in this section. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.rule_count = rule_count
        VapiStruct.__init__(self)


PBRSection._set_binding_type(type.StructType(
    'com.vmware.nsx.model.PBR_section', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'rule_count': type.OptionalType(type.IntegerType()),
    },
    PBRSection,
    False,
    None))



class PBRSectionListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`PBRSection` or ``None``
        :param results: List of the PBR sections.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


PBRSectionListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.PBR_section_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'PBRSection'))),
    },
    PBRSectionListResult,
    False,
    None))



class PBRSectionRuleList(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'rule_count': 'rule_count',
                            'rules': 'rules',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 rule_count=None,
                 rules=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  rule_count: :class:`long` or ``None``
        :param rule_count: Number of rules in this section. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  rules: :class:`list` of :class:`PBRRule` or ``None``
        :param rules: List of PBR rules in the section.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.rule_count = rule_count
        self.rules = rules
        VapiStruct.__init__(self)


PBRSectionRuleList._set_binding_type(type.StructType(
    'com.vmware.nsx.model.PBR_section_rule_list', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'rule_count': type.OptionalType(type.IntegerType()),
        'rules': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'PBRRule'))),
    },
    PBRSectionRuleList,
    False,
    None))



class PBRService(VapiStruct):
    """
    Type to define services associated with every rule

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'is_valid': 'is_valid',
                            'target_display_name': 'target_display_name',
                            'target_id': 'target_id',
                            'target_type': 'target_type',
                            'service': 'service',
                            }

    def __init__(self,
                 is_valid=None,
                 target_display_name=None,
                 target_id=None,
                 target_type=None,
                 service=None,
                ):
        """
        :type  is_valid: :class:`bool` or ``None``
        :param is_valid: Will be set to false if the referenced NSX resource has been
            deleted.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  target_display_name: :class:`str` or ``None``
        :param target_display_name: Display name of the NSX resource.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  target_id: :class:`str` or ``None``
        :param target_id: Identifier of the NSX resource.
        :type  target_type: :class:`str` or ``None``
        :param target_type: Type of the NSX resource.
        :type  service: :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param service: Distributed Service API accepts raw protocol and ports as part of
            NS service element in Distributed Service Rule that describes
            traffic corresponding to an NSService.
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`NSServiceElement`. When methods return a value of this
            class as a return value, the attribute will contain all the
            attributes defined in :class:`NSServiceElement`.
        """
        self.is_valid = is_valid
        self.target_display_name = target_display_name
        self.target_id = target_id
        self.target_type = target_type
        self.service = service
        VapiStruct.__init__(self)


PBRService._set_binding_type(type.StructType(
    'com.vmware.nsx.model.PBR_service', {
        'is_valid': type.OptionalType(type.BooleanType()),
        'target_display_name': type.OptionalType(type.StringType()),
        'target_id': type.OptionalType(type.StringType()),
        'target_type': type.OptionalType(type.StringType()),
        'service': type.OptionalType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'NSServiceElement')])),
    },
    PBRService,
    False,
    None))



class PBRStats(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'byte_count': 'byte_count',
                            'packet_count': 'packet_count',
                            'rule_id': 'rule_id',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 byte_count=None,
                 packet_count=None,
                 rule_id=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  byte_count: :class:`long` or ``None``
        :param byte_count: Aggregated number of bytes processed by the rule. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  packet_count: :class:`long` or ``None``
        :param packet_count: Aggregated number of packets processed by the rule. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  rule_id: :class:`str` or ``None``
        :param rule_id: Rule Identifier of the PBR rule. This is a globally unique number.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.byte_count = byte_count
        self.packet_count = packet_count
        self.rule_id = rule_id
        VapiStruct.__init__(self)


PBRStats._set_binding_type(type.StructType(
    'com.vmware.nsx.model.PBR_stats', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'byte_count': type.OptionalType(type.IntegerType()),
        'packet_count': type.OptionalType(type.IntegerType()),
        'rule_id': type.OptionalType(type.StringType()),
    },
    PBRStats,
    False,
    None))



class PBRStatsList(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            'section_id': 'section_id',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                 section_id=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`PBRStats` or ``None``
        :param results: List of rule statistics.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  section_id: :class:`str` or ``None``
        :param section_id: PBR section identifier.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        self.section_id = section_id
        VapiStruct.__init__(self)


PBRStatsList._set_binding_type(type.StructType(
    'com.vmware.nsx.model.PBR_stats_list', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'PBRStats'))),
        'section_id': type.OptionalType(type.StringType()),
    },
    PBRStatsList,
    False,
    None))



class PackageLoggingLevels(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    LOGGING_LEVEL_OFF = "OFF"
    """


    """
    LOGGING_LEVEL_FATAL = "FATAL"
    """


    """
    LOGGING_LEVEL_ERROR = "ERROR"
    """


    """
    LOGGING_LEVEL_WARN = "WARN"
    """


    """
    LOGGING_LEVEL_INFO = "INFO"
    """


    """
    LOGGING_LEVEL_DEBUG = "DEBUG"
    """


    """
    LOGGING_LEVEL_TRACE = "TRACE"
    """


    """



    _canonical_to_pep_names = {
                            'logging_level': 'logging_level',
                            'package_name': 'package_name',
                            }

    def __init__(self,
                 logging_level=None,
                 package_name=None,
                ):
        """
        :type  logging_level: :class:`str` or ``None``
        :param logging_level: Possible values are: 
            
            * :attr:`PackageLoggingLevels.LOGGING_LEVEL_OFF`
            * :attr:`PackageLoggingLevels.LOGGING_LEVEL_FATAL`
            * :attr:`PackageLoggingLevels.LOGGING_LEVEL_ERROR`
            * :attr:`PackageLoggingLevels.LOGGING_LEVEL_WARN`
            * :attr:`PackageLoggingLevels.LOGGING_LEVEL_INFO`
            * :attr:`PackageLoggingLevels.LOGGING_LEVEL_DEBUG`
            * :attr:`PackageLoggingLevels.LOGGING_LEVEL_TRACE`
            
             Logging levels per package
        :type  package_name: :class:`str` or ``None``
        :param package_name: Package name
        """
        self.logging_level = logging_level
        self.package_name = package_name
        VapiStruct.__init__(self)


PackageLoggingLevels._set_binding_type(type.StructType(
    'com.vmware.nsx.model.package_logging_levels', {
        'logging_level': type.OptionalType(type.StringType()),
        'package_name': type.OptionalType(type.StringType()),
    },
    PackageLoggingLevels,
    False,
    None))



class PacketAddressClassifier(VapiStruct):
    """
    A packet is classified to have an address binding, if its address
    configuration matches with all user specified properties.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'ip_address': 'ip_address',
                            'mac_address': 'mac_address',
                            'vlan': 'vlan',
                            }

    def __init__(self,
                 ip_address=None,
                 mac_address=None,
                 vlan=None,
                ):
        """
        :type  ip_address: :class:`str` or ``None``
        :param ip_address: A single IP address or a subnet, e.g. x.x.x.x or x.x.x.x/y format:
            address-or-block-or-range
        :type  mac_address: :class:`str` or ``None``
        :param mac_address: A single MAC address format: mac-address
        :type  vlan: :class:`long` or ``None``
        :param vlan: Virtual Local Area Network Identifier format: int64
        """
        self.ip_address = ip_address
        self.mac_address = mac_address
        self.vlan = vlan
        VapiStruct.__init__(self)


PacketAddressClassifier._set_binding_type(type.StructType(
    'com.vmware.nsx.model.packet_address_classifier', {
        'ip_address': type.OptionalType(type.StringType()),
        'mac_address': type.OptionalType(type.StringType()),
        'vlan': type.OptionalType(type.IntegerType()),
    },
    PacketAddressClassifier,
    False,
    None))



class PacketCaptureOption(VapiStruct):
    """
    The option is used to filter data on given node.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    NAME_ETHTYPE = "ETHTYPE"
    """


    """
    NAME_MAC = "MAC"
    """


    """
    NAME_SRCMAC = "SRCMAC"
    """


    """
    NAME_DSTMAC = "DSTMAC"
    """


    """
    NAME_VLAN = "VLAN"
    """


    """
    NAME_IP = "IP"
    """


    """
    NAME_SRCIP = "SRCIP"
    """


    """
    NAME_DSTIP = "DSTIP"
    """


    """
    NAME_IPPROTO = "IPPROTO"
    """


    """
    NAME_PORT = "PORT"
    """


    """
    NAME_SRCPORT = "SRCPORT"
    """


    """
    NAME_DSTPORT = "DSTPORT"
    """


    """
    NAME_VNI = "VNI"
    """


    """
    NAME_IPPROTO6 = "IPPROTO6"
    """


    """
    NAME_IP6 = "IP6"
    """


    """
    NAME_SRCIP6 = "SRCIP6"
    """


    """
    NAME_DSTIP6 = "DSTIP6"
    """


    """



    _canonical_to_pep_names = {
                            'name': 'name',
                            'value': 'value',
                            }

    def __init__(self,
                 name=None,
                 value=None,
                ):
        """
        :type  name: :class:`str` or ``None``
        :param name: Possible values are: 
            
            * :attr:`PacketCaptureOption.NAME_ETHTYPE`
            * :attr:`PacketCaptureOption.NAME_MAC`
            * :attr:`PacketCaptureOption.NAME_SRCMAC`
            * :attr:`PacketCaptureOption.NAME_DSTMAC`
            * :attr:`PacketCaptureOption.NAME_VLAN`
            * :attr:`PacketCaptureOption.NAME_IP`
            * :attr:`PacketCaptureOption.NAME_SRCIP`
            * :attr:`PacketCaptureOption.NAME_DSTIP`
            * :attr:`PacketCaptureOption.NAME_IPPROTO`
            * :attr:`PacketCaptureOption.NAME_PORT`
            * :attr:`PacketCaptureOption.NAME_SRCPORT`
            * :attr:`PacketCaptureOption.NAME_DSTPORT`
            * :attr:`PacketCaptureOption.NAME_VNI`
            * :attr:`PacketCaptureOption.NAME_IPPROTO6`
            * :attr:`PacketCaptureOption.NAME_IP6`
            * :attr:`PacketCaptureOption.NAME_SRCIP6`
            * :attr:`PacketCaptureOption.NAME_DSTIP6`
            
            The avaiable option names in the enum can be used to filter the
            capture data.
        :type  value: :class:`str` or ``None``
        :param value: Define the capture value according to the given capture option.
        """
        self.name = name
        self.value = value
        VapiStruct.__init__(self)


PacketCaptureOption._set_binding_type(type.StructType(
    'com.vmware.nsx.model.packet_capture_option', {
        'name': type.OptionalType(type.StringType()),
        'value': type.OptionalType(type.StringType()),
    },
    PacketCaptureOption,
    False,
    None))



class PacketCaptureOptionList(VapiStruct):
    """
    List of packet capture options to filter data in capture process.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'values': 'values',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 values=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  values: :class:`list` of :class:`PacketCaptureOption` or ``None``
        :param values: Packet capture option collection
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.values = values
        VapiStruct.__init__(self)


PacketCaptureOptionList._set_binding_type(type.StructType(
    'com.vmware.nsx.model.packet_capture_option_list', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'values': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'PacketCaptureOption'))),
    },
    PacketCaptureOptionList,
    False,
    None))



class PacketCaptureRequest(VapiStruct):
    """
    This type is used to create packet request on give node. Need to specify
    related parameters according to the capture point.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    CAPMODE_STANDALONE = "STANDALONE"
    """


    """
    CAPMODE_STREAM = "STREAM"
    """


    """
    CAPPOINT_VNIC = "VNIC"
    """


    """
    CAPPOINT_VMKNIC = "VMKNIC"
    """


    """
    CAPPOINT_VMNIC = "VMNIC"
    """


    """
    CAPPOINT_VDRPORT = "VDRPORT"
    """


    """
    CAPPOINT_DVFILTER = "DVFILTER"
    """


    """
    CAPPOINT_LOGICALPORT = "LOGICALPORT"
    """


    """
    CAPPOINT_FCPORT = "FCPORT"
    """


    """
    CAPPOINT_VIF = "VIF"
    """


    """
    CAPPOINT_PNIC = "PNIC"
    """


    """
    CAPSOURCE_CLI = "CLI"
    """


    """
    CAPSOURCE_UI = "UI"
    """


    """
    DIRECTION_INPUT = "INPUT"
    """


    """
    DIRECTION_OUTPUT = "OUTPUT"
    """


    """
    DIRECTION_DUAL = "DUAL"
    """


    """
    FILTERTYPE_PRE = "PRE"
    """


    """
    FILTERTYPE_POST = "POST"
    """


    """



    _canonical_to_pep_names = {
                            'capamount': 'capamount',
                            'capcore': 'capcore',
                            'capduration': 'capduration',
                            'capfilesize': 'capfilesize',
                            'capmode': 'capmode',
                            'cappoint': 'cappoint',
                            'caprate': 'caprate',
                            'capsnaplen': 'capsnaplen',
                            'capsource': 'capsource',
                            'capvalue': 'capvalue',
                            'direction': 'direction',
                            'filtertype': 'filtertype',
                            'node': 'node',
                            'node_ip': 'node_ip',
                            'options': 'options',
                            'streamaddress': 'streamaddress',
                            'streamport': 'streamport',
                            }

    def __init__(self,
                 capamount=None,
                 capcore=None,
                 capduration=None,
                 capfilesize=None,
                 capmode=None,
                 cappoint=None,
                 caprate=None,
                 capsnaplen=None,
                 capsource=None,
                 capvalue=None,
                 direction=None,
                 filtertype=None,
                 node=None,
                 node_ip=None,
                 options=None,
                 streamaddress=None,
                 streamport=None,
                ):
        """
        :type  capamount: :class:`long` or ``None``
        :param capamount: Define the packet capture amount size. format: int32
        :type  capcore: :class:`long` or ``None``
        :param capcore: The CPU core id on Edge node. format: int32
        :type  capduration: :class:`long` or ``None``
        :param capduration: Define the packet capture duration time. After the capture duration
            time, the capture process will stop working. format: int32
        :type  capfilesize: :class:`long` or ``None``
        :param capfilesize: Define the packet capture file size limit. format: int32
        :type  capmode: :class:`str` or ``None``
        :param capmode: Possible values are: 
            
            * :attr:`PacketCaptureRequest.CAPMODE_STANDALONE`
            * :attr:`PacketCaptureRequest.CAPMODE_STREAM`
            
            Define the capture streaming mode. The STREAM mode will send the
            data to given stream address and port. And the STANDALONE mode will
            save the capture file in local folder.
        :type  cappoint: :class:`str` or ``None``
        :param cappoint: Possible values are: 
            
            * :attr:`PacketCaptureRequest.CAPPOINT_VNIC`
            * :attr:`PacketCaptureRequest.CAPPOINT_VMKNIC`
            * :attr:`PacketCaptureRequest.CAPPOINT_VMNIC`
            * :attr:`PacketCaptureRequest.CAPPOINT_VDRPORT`
            * :attr:`PacketCaptureRequest.CAPPOINT_DVFILTER`
            * :attr:`PacketCaptureRequest.CAPPOINT_LOGICALPORT`
            * :attr:`PacketCaptureRequest.CAPPOINT_FCPORT`
            * :attr:`PacketCaptureRequest.CAPPOINT_VIF`
            * :attr:`PacketCaptureRequest.CAPPOINT_PNIC`
            
             Define the point to capture data.
        :type  caprate: :class:`long` or ``None``
        :param caprate: Define the rate of packet capture process. format: int32
        :type  capsnaplen: :class:`long` or ``None``
        :param capsnaplen: Limit the number of bytes captured from each packet. format: int32
        :type  capsource: :class:`str` or ``None``
        :param capsource: Possible values are: 
            
            * :attr:`PacketCaptureRequest.CAPSOURCE_CLI`
            * :attr:`PacketCaptureRequest.CAPSOURCE_UI`
            
             This type is used to differenite the incoming request from CLI/UI.
        :type  capvalue: :class:`str` or ``None``
        :param capvalue: Define the capture value of given capture point.
        :type  direction: :class:`str` or ``None``
        :param direction: Possible values are: 
            
            * :attr:`PacketCaptureRequest.DIRECTION_INPUT`
            * :attr:`PacketCaptureRequest.DIRECTION_OUTPUT`
            * :attr:`PacketCaptureRequest.DIRECTION_DUAL`
            
            Define the capture direction. Support three types
            INPUT/OUTPUT/DUAL.
        :type  filtertype: :class:`str` or ``None``
        :param filtertype: Possible values are: 
            
            * :attr:`PacketCaptureRequest.FILTERTYPE_PRE`
            * :attr:`PacketCaptureRequest.FILTERTYPE_POST`
            
             Define the capture filter type. Support PRE/POST mode.
        :type  node: :class:`str` or ``None``
        :param node: Define the transport node to capture data.
        :type  node_ip: :class:`str` or ``None``
        :param node_ip: Define the transport node to capture data. format: ip
        :type  options: :class:`PacketCaptureOptionList` or ``None``
        :param options: Define the packet capture additional options to filter the capture
            data.
        :type  streamaddress: :class:`str` or ``None``
        :param streamaddress: Set the stream address to receive the capture packet.
        :type  streamport: :class:`long` or ``None``
        :param streamport: Set the stream port to receive the capture packet. The STREAM mode
            is based on GRE-in-UDP Encapsulation(RFC8086). Packets are sent to
            UDP port 4754. format: int32
        """
        self.capamount = capamount
        self.capcore = capcore
        self.capduration = capduration
        self.capfilesize = capfilesize
        self.capmode = capmode
        self.cappoint = cappoint
        self.caprate = caprate
        self.capsnaplen = capsnaplen
        self.capsource = capsource
        self.capvalue = capvalue
        self.direction = direction
        self.filtertype = filtertype
        self.node = node
        self.node_ip = node_ip
        self.options = options
        self.streamaddress = streamaddress
        self.streamport = streamport
        VapiStruct.__init__(self)


PacketCaptureRequest._set_binding_type(type.StructType(
    'com.vmware.nsx.model.packet_capture_request', {
        'capamount': type.OptionalType(type.IntegerType()),
        'capcore': type.OptionalType(type.IntegerType()),
        'capduration': type.OptionalType(type.IntegerType()),
        'capfilesize': type.OptionalType(type.IntegerType()),
        'capmode': type.OptionalType(type.StringType()),
        'cappoint': type.OptionalType(type.StringType()),
        'caprate': type.OptionalType(type.IntegerType()),
        'capsnaplen': type.OptionalType(type.IntegerType()),
        'capsource': type.OptionalType(type.StringType()),
        'capvalue': type.OptionalType(type.StringType()),
        'direction': type.OptionalType(type.StringType()),
        'filtertype': type.OptionalType(type.StringType()),
        'node': type.OptionalType(type.StringType()),
        'node_ip': type.OptionalType(type.StringType()),
        'options': type.OptionalType(type.ReferenceType(__name__, 'PacketCaptureOptionList')),
        'streamaddress': type.OptionalType(type.StringType()),
        'streamport': type.OptionalType(type.IntegerType()),
    },
    PacketCaptureRequest,
    False,
    None))



class PacketCaptureSession(VapiStruct):
    """
    Packet capture session information.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    SESSIONSTATUS_CREATED = "CREATED"
    """


    """
    SESSIONSTATUS_STARTED = "STARTED"
    """


    """
    SESSIONSTATUS_STOPPED = "STOPPED"
    """


    """
    SESSIONSTATUS_FINISHED = "FINISHED"
    """


    """
    SESSIONSTATUS_ERROR = "ERROR"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'endtime': 'endtime',
                            'errormsg': 'errormsg',
                            'filelocation': 'filelocation',
                            'filesize': 'filesize',
                            'request': 'request',
                            'sessionid': 'sessionid',
                            'sessionname': 'sessionname',
                            'sessionstatus': 'sessionstatus',
                            'starttime': 'starttime',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 endtime=None,
                 errormsg=None,
                 filelocation=None,
                 filesize=None,
                 request=None,
                 sessionid=None,
                 sessionname=None,
                 sessionstatus=None,
                 starttime=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  endtime: :class:`long` or ``None``
        :param endtime: Timestamp when session was stopped in epoch millisecond. format:
            int64
        :type  errormsg: :class:`str` or ``None``
        :param errormsg: Error messasge in capture.
        :type  filelocation: :class:`str` or ``None``
        :param filelocation: Packet capture file location.
        :type  filesize: :class:`long` or ``None``
        :param filesize: Packet capture file Size in bytes. format: int32
        :type  request: :class:`PacketCaptureRequest` or ``None``
        :param request: Packet capture request information.
        :type  sessionid: :class:`str` or ``None``
        :param sessionid: Packet capture session id.
        :type  sessionname: :class:`str` or ``None``
        :param sessionname: Packet capture session name.
        :type  sessionstatus: :class:`str` or ``None``
        :param sessionstatus: Possible values are: 
            
            * :attr:`PacketCaptureSession.SESSIONSTATUS_CREATED`
            * :attr:`PacketCaptureSession.SESSIONSTATUS_STARTED`
            * :attr:`PacketCaptureSession.SESSIONSTATUS_STOPPED`
            * :attr:`PacketCaptureSession.SESSIONSTATUS_FINISHED`
            * :attr:`PacketCaptureSession.SESSIONSTATUS_ERROR`
            
             Packet capture session status.
        :type  starttime: :class:`long` or ``None``
        :param starttime: Timestamp when session was created in epoch millisecond. format:
            int64
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.endtime = endtime
        self.errormsg = errormsg
        self.filelocation = filelocation
        self.filesize = filesize
        self.request = request
        self.sessionid = sessionid
        self.sessionname = sessionname
        self.sessionstatus = sessionstatus
        self.starttime = starttime
        VapiStruct.__init__(self)


PacketCaptureSession._set_binding_type(type.StructType(
    'com.vmware.nsx.model.packet_capture_session', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'endtime': type.OptionalType(type.IntegerType()),
        'errormsg': type.OptionalType(type.StringType()),
        'filelocation': type.OptionalType(type.StringType()),
        'filesize': type.OptionalType(type.IntegerType()),
        'request': type.OptionalType(type.ReferenceType(__name__, 'PacketCaptureRequest')),
        'sessionid': type.OptionalType(type.StringType()),
        'sessionname': type.OptionalType(type.StringType()),
        'sessionstatus': type.OptionalType(type.StringType()),
        'starttime': type.OptionalType(type.IntegerType()),
    },
    PacketCaptureSession,
    False,
    None))



class PacketCaptureSessionList(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Total capture session count format: int64
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`PacketCaptureSession` or ``None``
        :param results: Packet capture list for all sessoins
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


PacketCaptureSessionList._set_binding_type(type.StructType(
    'com.vmware.nsx.model.packet_capture_session_list', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'PacketCaptureSession'))),
    },
    PacketCaptureSessionList,
    False,
    None))



class PacketData(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "PacketData"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    RESOURCE_TYPE_BINARYPACKETDATA = "BinaryPacketData"
    """


    """
    RESOURCE_TYPE_FIELDSPACKETDATA = "FieldsPacketData"
    """


    """
    TRANSPORT_TYPE_BROADCAST = "BROADCAST"
    """


    """
    TRANSPORT_TYPE_UNICAST = "UNICAST"
    """


    """
    TRANSPORT_TYPE_MULTICAST = "MULTICAST"
    """


    """
    TRANSPORT_TYPE_UNKNOWN = "UNKNOWN"
    """


    """



    _canonical_to_pep_names = {
                            'frame_size': 'frame_size',
                            'resource_type': 'resource_type',
                            'routed': 'routed',
                            'transport_type': 'transport_type',
                            }

    def __init__(self,
                 frame_size=None,
                 resource_type='PacketData',
                 routed=None,
                 transport_type=None,
                ):
        """
        :type  frame_size: :class:`long` or ``None``
        :param frame_size: If the requested frame_size is too small (given the payload and
            traceflow metadata requirement of 16 bytes), the traceflow request
            will fail with an appropriate message. The frame will be zero
            padded to the requested size. format: int64
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`PacketData.RESOURCE_TYPE_BINARYPACKETDATA`
            * :attr:`PacketData.RESOURCE_TYPE_FIELDSPACKETDATA`
            
             Packet configuration
        :type  routed: :class:`bool` or ``None``
        :param routed: A flag, when set true, indicates that the traceflow packet is of L3
            routing.
        :type  transport_type: :class:`str` or ``None``
        :param transport_type: Possible values are: 
            
            * :attr:`PacketData.TRANSPORT_TYPE_BROADCAST`
            * :attr:`PacketData.TRANSPORT_TYPE_UNICAST`
            * :attr:`PacketData.TRANSPORT_TYPE_MULTICAST`
            * :attr:`PacketData.TRANSPORT_TYPE_UNKNOWN`
            
             transport type of the traceflow packet
        """
        self.frame_size = frame_size
        self._resource_type = resource_type
        self.routed = routed
        self.transport_type = transport_type
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

PacketData._set_binding_type(type.StructType(
    'com.vmware.nsx.model.packet_data', {
        'frame_size': type.OptionalType(type.IntegerType()),
        'resource_type': type.StringType(),
        'routed': type.OptionalType(type.BooleanType()),
        'transport_type': type.OptionalType(type.StringType()),
    },
    PacketData,
    False,
    None))



class PacketTypeAndCounter(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'counter': 'counter',
                            'packet_type': 'packet_type',
                            }

    def __init__(self,
                 counter=None,
                 packet_type=None,
                ):
        """
        :type  counter: :class:`long` or ``None``
        :param counter: The number of packets. format: int64
        :type  packet_type: :class:`str` or ``None``
        :param packet_type: The type of the packets
        """
        self.counter = counter
        self.packet_type = packet_type
        VapiStruct.__init__(self)


PacketTypeAndCounter._set_binding_type(type.StructType(
    'com.vmware.nsx.model.packet_type_and_counter', {
        'counter': type.OptionalType(type.IntegerType()),
        'packet_type': type.OptionalType(type.StringType()),
    },
    PacketTypeAndCounter,
    False,
    None))



class PacketsDroppedBySecurity(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'bpdu_filter_dropped': 'bpdu_filter_dropped',
                            'dhcp_client_dropped_ipv4': 'dhcp_client_dropped_ipv4',
                            'dhcp_client_dropped_ipv6': 'dhcp_client_dropped_ipv6',
                            'dhcp_server_dropped_ipv4': 'dhcp_server_dropped_ipv4',
                            'dhcp_server_dropped_ipv6': 'dhcp_server_dropped_ipv6',
                            'spoof_guard_dropped': 'spoof_guard_dropped',
                            }

    def __init__(self,
                 bpdu_filter_dropped=None,
                 dhcp_client_dropped_ipv4=None,
                 dhcp_client_dropped_ipv6=None,
                 dhcp_server_dropped_ipv4=None,
                 dhcp_server_dropped_ipv6=None,
                 spoof_guard_dropped=None,
                ):
        """
        :type  bpdu_filter_dropped: :class:`long` or ``None``
        :param bpdu_filter_dropped: The number of packets dropped by \"BPDU filter\". format: int64
        :type  dhcp_client_dropped_ipv4: :class:`long` or ``None``
        :param dhcp_client_dropped_ipv4: The number of IPv4 packets dropped by \"DHCP client block\".
            format: int64
        :type  dhcp_client_dropped_ipv6: :class:`long` or ``None``
        :param dhcp_client_dropped_ipv6: The number of IPv6 packets dropped by \"DHCP client block\".
            format: int64
        :type  dhcp_server_dropped_ipv4: :class:`long` or ``None``
        :param dhcp_server_dropped_ipv4: The number of IPv4 packets dropped by \"DHCP server block\".
            format: int64
        :type  dhcp_server_dropped_ipv6: :class:`long` or ``None``
        :param dhcp_server_dropped_ipv6: The number of IPv6 packets dropped by \"DHCP server block\".
            format: int64
        :type  spoof_guard_dropped: :class:`list` of :class:`PacketTypeAndCounter` or ``None``
        :param spoof_guard_dropped: The packets dropped by \"Spoof Guard\"; supported packet types are
            IPv4, IPv6, ARP, ND, non-IP.
        """
        self.bpdu_filter_dropped = bpdu_filter_dropped
        self.dhcp_client_dropped_ipv4 = dhcp_client_dropped_ipv4
        self.dhcp_client_dropped_ipv6 = dhcp_client_dropped_ipv6
        self.dhcp_server_dropped_ipv4 = dhcp_server_dropped_ipv4
        self.dhcp_server_dropped_ipv6 = dhcp_server_dropped_ipv6
        self.spoof_guard_dropped = spoof_guard_dropped
        VapiStruct.__init__(self)


PacketsDroppedBySecurity._set_binding_type(type.StructType(
    'com.vmware.nsx.model.packets_dropped_by_security', {
        'bpdu_filter_dropped': type.OptionalType(type.IntegerType()),
        'dhcp_client_dropped_ipv4': type.OptionalType(type.IntegerType()),
        'dhcp_client_dropped_ipv6': type.OptionalType(type.IntegerType()),
        'dhcp_server_dropped_ipv4': type.OptionalType(type.IntegerType()),
        'dhcp_server_dropped_ipv6': type.OptionalType(type.IntegerType()),
        'spoof_guard_dropped': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'PacketTypeAndCounter'))),
    },
    PacketsDroppedBySecurity,
    False,
    None))



class PasswordAuthenticationScheme(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    SCHEME_NAME_PASSWORD = "password"
    """


    """



    _canonical_to_pep_names = {
                            'scheme_name': 'scheme_name',
                            'password': 'password',
                            'username': 'username',
                            }

    def __init__(self,
                 scheme_name=None,
                 password=None,
                 username=None,
                ):
        """
        :type  scheme_name: :class:`str` or ``None``
        :param scheme_name: Possible values are: 
            
            * :attr:`PasswordAuthenticationScheme.SCHEME_NAME_PASSWORD`
            
             Authentication scheme name
        :type  password: :class:`str` or ``None``
        :param password: Password to authenticate with
        :type  username: :class:`str` or ``None``
        :param username: User name to authenticate with
        """
        self.scheme_name = scheme_name
        self.password = password
        self.username = username
        VapiStruct.__init__(self)


PasswordAuthenticationScheme._set_binding_type(type.StructType(
    'com.vmware.nsx.model.password_authentication_scheme', {
        'scheme_name': type.OptionalType(type.StringType()),
        'password': type.OptionalType(type.StringType()),
        'username': type.OptionalType(type.StringType()),
    },
    PasswordAuthenticationScheme,
    False,
    None))



class PendingChange(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'request_id': 'request_id',
                            }

    def __init__(self,
                 request_id=None,
                ):
        """
        :type  request_id: :class:`str` or ``None``
        :param request_id: Request identifier of the API which modified the entity.
        """
        self.request_id = request_id
        VapiStruct.__init__(self)


PendingChange._set_binding_type(type.StructType(
    'com.vmware.nsx.model.pending_change', {
        'request_id': type.OptionalType(type.StringType()),
    },
    PendingChange,
    False,
    None))



class PerForwarderStatistics(VapiStruct):
    """
    Query statistics counters of a forwarder identified by domain names.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'domain_names': 'domain_names',
                            'upstream_statistics': 'upstream_statistics',
                            }

    def __init__(self,
                 domain_names=None,
                 upstream_statistics=None,
                ):
        """
        :type  domain_names: :class:`list` of :class:`str` or ``None``
        :param domain_names: Domain names configured for the forwarder. Empty if this is the
            default forwarder.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  upstream_statistics: :class:`list` of :class:`PerUpstreamServerStatistics` or ``None``
        :param upstream_statistics: Statistics per upstream server.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.domain_names = domain_names
        self.upstream_statistics = upstream_statistics
        VapiStruct.__init__(self)


PerForwarderStatistics._set_binding_type(type.StructType(
    'com.vmware.nsx.model.per_forwarder_statistics', {
        'domain_names': type.OptionalType(type.ListType(type.StringType())),
        'upstream_statistics': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'PerUpstreamServerStatistics'))),
    },
    PerForwarderStatistics,
    False,
    None))



class PerNodeDnsFailedQueries(VapiStruct):
    """
    The list of the failed DNS queries with entry count and timestamp. The
    entry count is for per active/standby transport node.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'node_id': 'node_id',
                            'results': 'results',
                            'timestamp': 'timestamp',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 node_id=None,
                 results=None,
                 timestamp=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  node_id: :class:`str` or ``None``
        :param node_id: The Uuid of active/standby transport node.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`DnsFailedQuery` or ``None``
        :param results: The list of failed DNS queries.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  timestamp: :class:`str` or ``None``
        :param timestamp: Timestamp of the request, in YYYY-MM-DD HH:MM:SS.zzz format.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.node_id = node_id
        self.results = results
        self.timestamp = timestamp
        VapiStruct.__init__(self)


PerNodeDnsFailedQueries._set_binding_type(type.StructType(
    'com.vmware.nsx.model.per_node_dns_failed_queries', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'node_id': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'DnsFailedQuery'))),
        'timestamp': type.OptionalType(type.StringType()),
    },
    PerNodeDnsFailedQueries,
    False,
    None))



class PerNodeUsedCacheStatistics(VapiStruct):
    """
    Query statistics counters of used cache from node

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'cached_entries': 'cached_entries',
                            'node_id': 'node_id',
                            'used_cache_size': 'used_cache_size',
                            }

    def __init__(self,
                 cached_entries=None,
                 node_id=None,
                 used_cache_size=None,
                ):
        """
        :type  cached_entries: :class:`long` or ``None``
        :param cached_entries: The total number of cached entries format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  node_id: :class:`str` or ``None``
        :param node_id: Uuid of active/standby transport node
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  used_cache_size: :class:`long` or ``None``
        :param used_cache_size: The memory size used in cache, in kb format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.cached_entries = cached_entries
        self.node_id = node_id
        self.used_cache_size = used_cache_size
        VapiStruct.__init__(self)


PerNodeUsedCacheStatistics._set_binding_type(type.StructType(
    'com.vmware.nsx.model.per_node_used_cache_statistics', {
        'cached_entries': type.OptionalType(type.IntegerType()),
        'node_id': type.OptionalType(type.StringType()),
        'used_cache_size': type.OptionalType(type.IntegerType()),
    },
    PerNodeUsedCacheStatistics,
    False,
    None))



class PerStepRestoreStatus(VapiStruct):
    """
    Restore step status

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    VALUE_INITIAL = "INITIAL"
    """


    """
    VALUE_RUNNING = "RUNNING"
    """


    """
    VALUE_SUSPENDED_BY_USER = "SUSPENDED_BY_USER"
    """


    """
    VALUE_SUSPENDED_FOR_USER_ACTION = "SUSPENDED_FOR_USER_ACTION"
    """


    """
    VALUE_FAILED = "FAILED"
    """


    """
    VALUE_SUCCESS = "SUCCESS"
    """


    """



    _canonical_to_pep_names = {
                            'description': 'description',
                            'value': 'value',
                            }

    def __init__(self,
                 description=None,
                 value=None,
                ):
        """
        :type  description: :class:`str` or ``None``
        :param description: A description of the restore status
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  value: :class:`str` or ``None``
        :param value: Possible values are: 
            
            * :attr:`PerStepRestoreStatus.VALUE_INITIAL`
            * :attr:`PerStepRestoreStatus.VALUE_RUNNING`
            * :attr:`PerStepRestoreStatus.VALUE_SUSPENDED_BY_USER`
            * :attr:`PerStepRestoreStatus.VALUE_SUSPENDED_FOR_USER_ACTION`
            * :attr:`PerStepRestoreStatus.VALUE_FAILED`
            * :attr:`PerStepRestoreStatus.VALUE_SUCCESS`
            
             Per step restore status value
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.description = description
        self.value = value
        VapiStruct.__init__(self)


PerStepRestoreStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.per_step_restore_status', {
        'description': type.OptionalType(type.StringType()),
        'value': type.OptionalType(type.StringType()),
    },
    PerStepRestoreStatus,
    False,
    None))



class PerUpstreamServerStatistics(VapiStruct):
    """
    Query statistics counters to an upstream server including successfully
    forwarded queries and failed queries.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'queries_failed': 'queries_failed',
                            'queries_succeeded': 'queries_succeeded',
                            'upstream_server': 'upstream_server',
                            }

    def __init__(self,
                 queries_failed=None,
                 queries_succeeded=None,
                 upstream_server=None,
                ):
        """
        :type  queries_failed: :class:`long` or ``None``
        :param queries_failed: Queries failed to forward. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  queries_succeeded: :class:`long` or ``None``
        :param queries_succeeded: Queries forwarded successfully format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  upstream_server: :class:`str` or ``None``
        :param upstream_server: Upstream server ip format: ip
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.queries_failed = queries_failed
        self.queries_succeeded = queries_succeeded
        self.upstream_server = upstream_server
        VapiStruct.__init__(self)


PerUpstreamServerStatistics._set_binding_type(type.StructType(
    'com.vmware.nsx.model.per_upstream_server_statistics', {
        'queries_failed': type.OptionalType(type.IntegerType()),
        'queries_succeeded': type.OptionalType(type.IntegerType()),
        'upstream_server': type.OptionalType(type.StringType()),
    },
    PerUpstreamServerStatistics,
    False,
    None))



class PhysicalServer(VapiStruct):
    """
    Details of physical/bare metal server. PhysicalServer is an abstraction for
    TransportNode with os_type RHELSERVER, UBUNTUSERVER, CENTOSSERVER,
    SLESSERVER, OELSERVER or WINDOWSSERVER. This entity will be used in
    grouping to provide micro-segmentation to physical servers. To add any new
    physical servers/perform any changes, use create/update TransportNode API.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    OS_TYPE_RHELSERVER = "RHELSERVER"
    """


    """
    OS_TYPE_UBUNTUSERVER = "UBUNTUSERVER"
    """


    """
    OS_TYPE_CENTOSSERVER = "CENTOSSERVER"
    """


    """
    OS_TYPE_SLESSERVER = "SLESSERVER"
    """


    """
    OS_TYPE_WINDOWSSERVER = "WINDOWSSERVER"
    """


    """
    OS_TYPE_OELSERVER = "OELSERVER"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'ip_addresses': 'ip_addresses',
                            'os_type': 'os_type',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 ip_addresses=None,
                 os_type=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  ip_addresses: :class:`list` of :class:`str` or ``None``
        :param ip_addresses: IP addresses of the physical server specified by the admin while
            registering as Transport node in nsx. format: ip
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  os_type: :class:`str` or ``None``
        :param os_type: Possible values are: 
            
            * :attr:`PhysicalServer.OS_TYPE_RHELSERVER`
            * :attr:`PhysicalServer.OS_TYPE_UBUNTUSERVER`
            * :attr:`PhysicalServer.OS_TYPE_CENTOSSERVER`
            * :attr:`PhysicalServer.OS_TYPE_SLESSERVER`
            * :attr:`PhysicalServer.OS_TYPE_WINDOWSSERVER`
            * :attr:`PhysicalServer.OS_TYPE_OELSERVER`
            
             OS type of the physical server.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.ip_addresses = ip_addresses
        self.os_type = os_type
        VapiStruct.__init__(self)


PhysicalServer._set_binding_type(type.StructType(
    'com.vmware.nsx.model.physical_server', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'ip_addresses': type.OptionalType(type.ListType(type.StringType())),
        'os_type': type.OptionalType(type.StringType()),
    },
    PhysicalServer,
    False,
    None))



class PhysicalServerListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`PhysicalServer` or ``None``
        :param results: List of physical servers.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


PhysicalServerListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.physical_server_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'PhysicalServer'))),
    },
    PhysicalServerListResult,
    False,
    None))



class PluginFileProperties(VapiStruct):
    """
    Plugin file properties

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'file_name': 'file_name',
                            'plugin_id': 'plugin_id',
                            'status': 'status',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 file_name=None,
                 plugin_id=None,
                 status=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  file_name: :class:`str` or ``None``
        :param file_name: File name
        :type  plugin_id: :class:`str` or ``None``
        :param plugin_id: Plugin id
        :type  status: :class:`str` or ``None``
        :param status: Upload status
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.file_name = file_name
        self.plugin_id = plugin_id
        self.status = status
        VapiStruct.__init__(self)


PluginFileProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.plugin_file_properties', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'file_name': type.OptionalType(type.StringType()),
        'plugin_id': type.OptionalType(type.StringType()),
        'status': type.OptionalType(type.StringType()),
    },
    PluginFileProperties,
    False,
    None))



class PluginStatus(VapiStruct):
    """
    Describes plugin status on node

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATUS_UNKNOWN = "UNKNOWN"
    """


    """
    STATUS_ENABLED = "ENABLED"
    """


    """
    STATUS_DISABLED = "DISABLED"
    """


    """



    _canonical_to_pep_names = {
                            'detail': 'detail',
                            'id': 'id',
                            'name': 'name',
                            'profile': 'profile',
                            'status': 'status',
                            }

    def __init__(self,
                 detail=None,
                 id=None,
                 name=None,
                 profile=None,
                 status=None,
                ):
        """
        :type  detail: :class:`str` or ``None``
        :param detail: Detail information of plugin.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  id: :class:`str` or ``None``
        :param id: Plugin id.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  name: :class:`str` or ``None``
        :param name: Plugin name.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  profile: :class:`str` or ``None``
        :param profile: Display the plugin profile content.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  status: :class:`str` or ``None``
        :param status: Possible values are: 
            
            * :attr:`PluginStatus.STATUS_UNKNOWN`
            * :attr:`PluginStatus.STATUS_ENABLED`
            * :attr:`PluginStatus.STATUS_DISABLED`
            
             Plugin status.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.detail = detail
        self.id = id
        self.name = name
        self.profile = profile
        self.status = status
        VapiStruct.__init__(self)


PluginStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.plugin_status', {
        'detail': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'name': type.OptionalType(type.StringType()),
        'profile': type.OptionalType(type.StringType()),
        'status': type.OptionalType(type.StringType()),
    },
    PluginStatus,
    False,
    None))



class PluginStatusList(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Total plugin count format: int64
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`PluginStatus` or ``None``
        :param results: System Health plugin status list
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


PluginStatusList._set_binding_type(type.StructType(
    'com.vmware.nsx.model.plugin_status_list', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'PluginStatus'))),
    },
    PluginStatusList,
    False,
    None))



class Pnic(VapiStruct):
    """
    Physical NIC specification

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'device_name': 'device_name',
                            'uplink_name': 'uplink_name',
                            }

    def __init__(self,
                 device_name=None,
                 uplink_name=None,
                ):
        """
        :type  device_name: :class:`str` or ``None``
        :param device_name: device name or key
        :type  uplink_name: :class:`str` or ``None``
        :param uplink_name: Uplink name for this Pnic. This name will be used to reference this
            Pnic in other configurations.
        """
        self.device_name = device_name
        self.uplink_name = uplink_name
        VapiStruct.__init__(self)


Pnic._set_binding_type(type.StructType(
    'com.vmware.nsx.model.pnic', {
        'device_name': type.OptionalType(type.StringType()),
        'uplink_name': type.OptionalType(type.StringType()),
    },
    Pnic,
    False,
    None))



class PnicBondStatus(VapiStruct):
    """
    pNIC/bond statuses

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATUS_UNKNOWN = "UNKNOWN"
    """


    """
    STATUS_UP = "UP"
    """


    """
    STATUS_DOWN = "DOWN"
    """


    """
    STATUS_DEGRADED = "DEGRADED"
    """


    """
    TYPE_UNKNOWN_TYPE = "UNKNOWN_TYPE"
    """


    """
    TYPE_PNIC = "PNIC"
    """


    """
    TYPE_BOND = "BOND"
    """


    """



    _canonical_to_pep_names = {
                            'name': 'name',
                            'status': 'status',
                            'type': 'type',
                            }

    def __init__(self,
                 name=None,
                 status=None,
                 type=None,
                ):
        """
        :type  name: :class:`str` or ``None``
        :param name: Name of the pNIC/bond
        :type  status: :class:`str` or ``None``
        :param status: Possible values are: 
            
            * :attr:`PnicBondStatus.STATUS_UNKNOWN`
            * :attr:`PnicBondStatus.STATUS_UP`
            * :attr:`PnicBondStatus.STATUS_DOWN`
            * :attr:`PnicBondStatus.STATUS_DEGRADED`
            
             Status of pNIC/bond
        :type  type: :class:`str` or ``None``
        :param type: Possible values are: 
            
            * :attr:`PnicBondStatus.TYPE_UNKNOWN_TYPE`
            * :attr:`PnicBondStatus.TYPE_PNIC`
            * :attr:`PnicBondStatus.TYPE_BOND`
            
             type, whether the object is a pNIC or a bond
        """
        self.name = name
        self.status = status
        self.type = type
        VapiStruct.__init__(self)


PnicBondStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.pnic_bond_status', {
        'name': type.OptionalType(type.StringType()),
        'status': type.OptionalType(type.StringType()),
        'type': type.OptionalType(type.StringType()),
    },
    PnicBondStatus,
    False,
    None))



class PnicBondStatusListResult(VapiStruct):
    """
    This object contains reference to list of pNIC/bond statuses

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`PnicBondStatus` or ``None``
        :param results: List of pNIC statuses belonging to the transport node
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


PnicBondStatusListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.pnic_bond_status_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'PnicBondStatus'))),
    },
    PnicBondStatusListResult,
    False,
    None))



class PnicMirrorDestination(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "PnicMirrorDestination"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'dest_pnics': 'dest_pnics',
                            'node_id': 'node_id',
                            'resource_type': 'resource_type',
                            }

    def __init__(self,
                 dest_pnics=None,
                 node_id=None,
                 resource_type='PnicMirrorDestination',
                ):
        """
        :type  dest_pnics: :class:`list` of :class:`str` or ``None``
        :param dest_pnics: Physical NIC device names to which to send the mirrored packets
        :type  node_id: :class:`str` or ``None``
        :param node_id: Transport node to which to send the mirrored packets
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            *
              :attr:`MirrorDestination.RESOURCE_TYPE_LOGICALPORTMIRRORDESTINATION`
            * :attr:`MirrorDestination.RESOURCE_TYPE_PNICMIRRORDESTINATION`
            * :attr:`MirrorDestination.RESOURCE_TYPE_IPMIRRORDESTINATION`
            
             Resource types of mirror destination
        """
        self.dest_pnics = dest_pnics
        self.node_id = node_id
        self._resource_type = resource_type
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

PnicMirrorDestination._set_binding_type(type.StructType(
    'com.vmware.nsx.model.pnic_mirror_destination', {
        'dest_pnics': type.OptionalType(type.ListType(type.StringType())),
        'node_id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
    },
    PnicMirrorDestination,
    False,
    None))



class PnicMirrorSource(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "PnicMirrorSource"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'encapsulated': 'encapsulated',
                            'node_id': 'node_id',
                            'source_pnics': 'source_pnics',
                            'resource_type': 'resource_type',
                            }

    def __init__(self,
                 encapsulated=None,
                 node_id=None,
                 source_pnics=None,
                 resource_type='PnicMirrorSource',
                ):
        """
        :type  encapsulated: :class:`bool` or ``None``
        :param encapsulated: Whether to filter encapsulated packet.
        :type  node_id: :class:`str` or ``None``
        :param node_id: Transport node identifier for the pnic located.
        :type  source_pnics: :class:`list` of :class:`str` or ``None``
        :param source_pnics: Source physical NIC device names
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`MirrorSource.RESOURCE_TYPE_LOGICALPORTMIRRORSOURCE`
            * :attr:`MirrorSource.RESOURCE_TYPE_PNICMIRRORSOURCE`
            * :attr:`MirrorSource.RESOURCE_TYPE_VLANMIRRORSOURCE`
            * :attr:`MirrorSource.RESOURCE_TYPE_LOGICALSWITCHMIRRORSOURCE`
            
             Resource types of mirror source
        """
        self.encapsulated = encapsulated
        self.node_id = node_id
        self.source_pnics = source_pnics
        self._resource_type = resource_type
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

PnicMirrorSource._set_binding_type(type.StructType(
    'com.vmware.nsx.model.pnic_mirror_source', {
        'encapsulated': type.OptionalType(type.BooleanType()),
        'node_id': type.OptionalType(type.StringType()),
        'source_pnics': type.OptionalType(type.ListType(type.StringType())),
        'resource_type': type.StringType(),
    },
    PnicMirrorSource,
    False,
    None))



class PointDefinition(VapiStruct):
    """
    Defines the point of a graph.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'drilldown_id': 'drilldown_id',
                            'field': 'field',
                            'navigation': 'navigation',
                            'tooltip': 'tooltip',
                            'x_value': 'x_value',
                            'y_value': 'y_value',
                            }

    def __init__(self,
                 drilldown_id=None,
                 field=None,
                 navigation=None,
                 tooltip=None,
                 x_value=None,
                 y_value=None,
                ):
        """
        :type  drilldown_id: :class:`str` or ``None``
        :param drilldown_id: Id of drilldown widget, if any. Id should be a valid id of an
            existing widget. A widget is considered as drilldown widget when it
            is associated with any other widget and provides more detailed
            information about any data item from the parent widget.
        :type  field: :class:`str` or ``None``
        :param field: An expression that represents the points of the graph
        :type  navigation: :class:`str` or ``None``
        :param navigation: Hyperlink of the specified UI page that provides details.
        :type  tooltip: :class:`list` of :class:`Tooltip` or ``None``
        :param tooltip: Multi-line text to be shown on tooltip while hovering over the
            point of a graph.
        :type  x_value: :class:`str` or ``None``
        :param x_value: Represents the variable for the X value of points that are plotted
            on the graph.
        :type  y_value: :class:`str` or ``None``
        :param y_value: Represents the variable for the Y value of points that are plotted
            on the graph.
        """
        self.drilldown_id = drilldown_id
        self.field = field
        self.navigation = navigation
        self.tooltip = tooltip
        self.x_value = x_value
        self.y_value = y_value
        VapiStruct.__init__(self)


PointDefinition._set_binding_type(type.StructType(
    'com.vmware.nsx.model.point_definition', {
        'drilldown_id': type.OptionalType(type.StringType()),
        'field': type.OptionalType(type.StringType()),
        'navigation': type.OptionalType(type.StringType()),
        'tooltip': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tooltip'))),
        'x_value': type.OptionalType(type.StringType()),
        'y_value': type.OptionalType(type.StringType()),
    },
    PointDefinition,
    False,
    None))



class PolicyBasedIPSecVPNSession(VapiStruct):
    """
    A Policy Based VPN requires to define protect rules that match local and
    peer subnets. IPSec security associations is negotiated for each pair of
    local and peer subnet.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "PolicyBasedIPSecVPNSession"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'policy_rules': 'policy_rules',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'enabled': 'enabled',
                            'ipsec_vpn_service_id': 'ipsec_vpn_service_id',
                            'local_endpoint_id': 'local_endpoint_id',
                            'peer_endpoint_id': 'peer_endpoint_id',
                            'tcp_mss_clamping': 'tcp_mss_clamping',
                            }

    def __init__(self,
                 policy_rules=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='PolicyBasedIPSecVPNSession',
                 tags=None,
                 enabled=None,
                 ipsec_vpn_service_id=None,
                 local_endpoint_id=None,
                 peer_endpoint_id=None,
                 tcp_mss_clamping=None,
                ):
        """
        :type  policy_rules: :class:`list` of :class:`IPSecVPNPolicyRule` or ``None``
        :param policy_rules: Policy rules
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`IPSecVPNSession.RESOURCE_TYPE_POLICYBASEDIPSECVPNSESSION`
            * :attr:`IPSecVPNSession.RESOURCE_TYPE_ROUTEBASEDIPSECVPNSESSION`
            
            A Policy Based VPN requires to define protect rules that match
            local and peer subnets. IPSec security associations is negotiated
            for each pair of local and peer subnet. A Route Based VPN is more
            flexible, more powerful and recommended over policy based VPN. IP
            Tunnel port is created and all traffic routed via tunnel port is
            protected. Routes can be configured statically or can be learned
            through BGP. A route based VPN is must for establishing redundant
            VPN session to remote site.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  enabled: :class:`bool` or ``None``
        :param enabled: Enable/Disable IPSec VPN session.
        :type  ipsec_vpn_service_id: :class:`str` or ``None``
        :param ipsec_vpn_service_id: Identifier of VPN Service linked with local endpoint.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  local_endpoint_id: :class:`str` or ``None``
        :param local_endpoint_id: Local endpoint identifier.
        :type  peer_endpoint_id: :class:`str` or ``None``
        :param peer_endpoint_id: Peer endpoint identifier.
        :type  tcp_mss_clamping: :class:`TcpMssClamping` or ``None``
        :param tcp_mss_clamping: 
        """
        self.policy_rules = policy_rules
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        self.enabled = enabled
        self.ipsec_vpn_service_id = ipsec_vpn_service_id
        self.local_endpoint_id = local_endpoint_id
        self.peer_endpoint_id = peer_endpoint_id
        self.tcp_mss_clamping = tcp_mss_clamping
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

PolicyBasedIPSecVPNSession._set_binding_type(type.StructType(
    'com.vmware.nsx.model.policy_based_IP_sec_VPN_session', {
        'policy_rules': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IPSecVPNPolicyRule'))),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'enabled': type.OptionalType(type.BooleanType()),
        'ipsec_vpn_service_id': type.OptionalType(type.StringType()),
        'local_endpoint_id': type.OptionalType(type.StringType()),
        'peer_endpoint_id': type.OptionalType(type.StringType()),
        'tcp_mss_clamping': type.OptionalType(type.ReferenceType(__name__, 'TcpMssClamping')),
    },
    PolicyBasedIPSecVPNSession,
    False,
    None))



class PoolMember(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    ADMIN_STATE_ENABLED = "ENABLED"
    """


    """
    ADMIN_STATE_DISABLED = "DISABLED"
    """


    """
    ADMIN_STATE_GRACEFUL_DISABLED = "GRACEFUL_DISABLED"
    """


    """



    _canonical_to_pep_names = {
                            'admin_state': 'admin_state',
                            'backup_member': 'backup_member',
                            'display_name': 'display_name',
                            'ip_address': 'ip_address',
                            'max_concurrent_connections': 'max_concurrent_connections',
                            'port': 'port',
                            'weight': 'weight',
                            }

    def __init__(self,
                 admin_state=None,
                 backup_member=None,
                 display_name=None,
                 ip_address=None,
                 max_concurrent_connections=None,
                 port=None,
                 weight=None,
                ):
        """
        :type  admin_state: :class:`str` or ``None``
        :param admin_state: Possible values are: 
            
            * :attr:`PoolMember.ADMIN_STATE_ENABLED`
            * :attr:`PoolMember.ADMIN_STATE_DISABLED`
            * :attr:`PoolMember.ADMIN_STATE_GRACEFUL_DISABLED`
            
             member admin state
        :type  backup_member: :class:`bool` or ``None``
        :param backup_member: Backup servers are typically configured with a sorry page
            indicating to the user that the application is currently
            unavailable. While the pool is active (a specified minimum number
            of pool members are active) BACKUP members are skipped during
            server selection. When the pool is inactive, incoming connections
            are sent to only the BACKUP member(s).
        :type  display_name: :class:`str` or ``None``
        :param display_name: pool member name
        :type  ip_address: :class:`str` or ``None``
        :param ip_address: pool member IP address format: ip
        :type  max_concurrent_connections: :class:`long` or ``None``
        :param max_concurrent_connections: To ensure members are not overloaded, connections to a member can
            be capped by the load balancer. When a member reaches this limit,
            it is skipped during server selection. If it is not specified, it
            means that connections are unlimited. format: int64
        :type  port: :class:`str` or ``None``
        :param port: If port is specified, all connections will be sent to this port.
            Only single port is supported. If unset, the same port the client
            connected to will be used, it could be overrode by
            default_pool_member_port setting in virtual server. The port should
            not specified for port range case. format: port-or-range
        :type  weight: :class:`long` or ``None``
        :param weight: Pool member weight is used for WEIGHTED_ROUND_ROBIN balancing
            algorithm. The weight value would be ignored in other algorithms.
            format: int64
        """
        self.admin_state = admin_state
        self.backup_member = backup_member
        self.display_name = display_name
        self.ip_address = ip_address
        self.max_concurrent_connections = max_concurrent_connections
        self.port = port
        self.weight = weight
        VapiStruct.__init__(self)


PoolMember._set_binding_type(type.StructType(
    'com.vmware.nsx.model.pool_member', {
        'admin_state': type.OptionalType(type.StringType()),
        'backup_member': type.OptionalType(type.BooleanType()),
        'display_name': type.OptionalType(type.StringType()),
        'ip_address': type.OptionalType(type.StringType()),
        'max_concurrent_connections': type.OptionalType(type.IntegerType()),
        'port': type.OptionalType(type.StringType()),
        'weight': type.OptionalType(type.IntegerType()),
    },
    PoolMember,
    False,
    None))



class PoolMemberGroup(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    IP_REVISION_FILTER_IPV4 = "IPV4"
    """


    """
    IP_REVISION_FILTER_IPV6 = "IPV6"
    """


    """
    IP_REVISION_FILTER_IPV4_IPV6 = "IPV4_IPV6"
    """


    """



    _canonical_to_pep_names = {
                            'customized_members': 'customized_members',
                            'grouping_object': 'grouping_object',
                            'ip_revision_filter': 'ip_revision_filter',
                            'max_ip_list_size': 'max_ip_list_size',
                            'port': 'port',
                            }

    def __init__(self,
                 customized_members=None,
                 grouping_object=None,
                 ip_revision_filter=None,
                 max_ip_list_size=None,
                 port=None,
                ):
        """
        :type  customized_members: :class:`list` of :class:`PoolMemberSetting` or ``None``
        :param customized_members: The list is used to show the customized pool member settings. User
            can only user pool member action API to update the admin state for
            a specific IP address.
        :type  grouping_object: :class:`ResourceReference` or ``None``
        :param grouping_object: Load balancer pool support grouping object as dynamic pool members.
            The IP list of the grouping object such as NSGroup would be used as
            pool member IP setting.
        :type  ip_revision_filter: :class:`str` or ``None``
        :param ip_revision_filter: Possible values are: 
            
            * :attr:`PoolMemberGroup.IP_REVISION_FILTER_IPV4`
            * :attr:`PoolMemberGroup.IP_REVISION_FILTER_IPV6`
            * :attr:`PoolMemberGroup.IP_REVISION_FILTER_IPV4_IPV6`
            
            Ip revision filter is used to filter IPv4 or IPv6 addresses from
            the grouping object. If the filter is not specified, both IPv4 and
            IPv6 addresses would be used as server IPs. The link local and
            loopback addresses would be always filtered out.
        :type  max_ip_list_size: :class:`long` or ``None``
        :param max_ip_list_size: The size is used to define the maximum number of grouping object IP
            address list. These IP addresses would be used as pool members. If
            the grouping object includes more than certain number of IP
            addresses, the redundant parts would be ignored and those IP
            addresses would not be treated as pool members. If the size is not
            specified, one member is budgeted for this dynamic pool so that the
            pool has at least one member even if some other dynamic pools grow
            beyond the capacity of load balancer service. Other members are
            picked according to available dynamic capacity. The unused members
            would be set to DISABLED so that the load balancer system itself is
            not overloaded during runtime. format: int64
        :type  port: :class:`long` or ``None``
        :param port: If port is specified, all connections will be sent to this port. If
            unset, the same port the client connected to will be used, it could
            be overridden by default_pool_member_ports setting in virtual
            server. The port should not specified for multiple ports case.
            format: int32
        """
        self.customized_members = customized_members
        self.grouping_object = grouping_object
        self.ip_revision_filter = ip_revision_filter
        self.max_ip_list_size = max_ip_list_size
        self.port = port
        VapiStruct.__init__(self)


PoolMemberGroup._set_binding_type(type.StructType(
    'com.vmware.nsx.model.pool_member_group', {
        'customized_members': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'PoolMemberSetting'))),
        'grouping_object': type.OptionalType(type.ReferenceType(__name__, 'ResourceReference')),
        'ip_revision_filter': type.OptionalType(type.StringType()),
        'max_ip_list_size': type.OptionalType(type.IntegerType()),
        'port': type.OptionalType(type.IntegerType()),
    },
    PoolMemberGroup,
    False,
    None))



class PoolMemberSetting(VapiStruct):
    """
    The setting is used to add, update or remove pool members from pool. For
    static pool members, admin_state, display_name and weight can be updated.
    For dynamic pool members, only admin_state can be updated.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    ADMIN_STATE_ENABLED = "ENABLED"
    """


    """
    ADMIN_STATE_DISABLED = "DISABLED"
    """


    """
    ADMIN_STATE_GRACEFUL_DISABLED = "GRACEFUL_DISABLED"
    """


    """



    _canonical_to_pep_names = {
                            'admin_state': 'admin_state',
                            'display_name': 'display_name',
                            'ip_address': 'ip_address',
                            'port': 'port',
                            'weight': 'weight',
                            }

    def __init__(self,
                 admin_state=None,
                 display_name=None,
                 ip_address=None,
                 port=None,
                 weight=None,
                ):
        """
        :type  admin_state: :class:`str` or ``None``
        :param admin_state: Possible values are: 
            
            * :attr:`PoolMemberSetting.ADMIN_STATE_ENABLED`
            * :attr:`PoolMemberSetting.ADMIN_STATE_DISABLED`
            * :attr:`PoolMemberSetting.ADMIN_STATE_GRACEFUL_DISABLED`
            
             Member admin state
        :type  display_name: :class:`str` or ``None``
        :param display_name: Only applicable to static pool members. If supplied for a pool
            defined by a grouping object, update API would fail.
        :type  ip_address: :class:`str` or ``None``
        :param ip_address: Pool member IP address format: ip
        :type  port: :class:`str` or ``None``
        :param port: Pool member port number format: port-or-range
        :type  weight: :class:`long` or ``None``
        :param weight: Only applicable to static pool members. If supplied for a pool
            defined by a grouping object, update API would fail. format: int64
        """
        self.admin_state = admin_state
        self.display_name = display_name
        self.ip_address = ip_address
        self.port = port
        self.weight = weight
        VapiStruct.__init__(self)


PoolMemberSetting._set_binding_type(type.StructType(
    'com.vmware.nsx.model.pool_member_setting', {
        'admin_state': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'ip_address': type.OptionalType(type.StringType()),
        'port': type.OptionalType(type.StringType()),
        'weight': type.OptionalType(type.IntegerType()),
    },
    PoolMemberSetting,
    False,
    None))



class PoolMemberSettingList(VapiStruct):
    """
    List of PoolMemberSetting

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'members': 'members',
                            }

    def __init__(self,
                 members=None,
                ):
        """
        :type  members: :class:`list` of :class:`PoolMemberSetting` or ``None``
        :param members: List of pool member settings to be passed to add, update and remove
            APIs
        """
        self.members = members
        VapiStruct.__init__(self)


PoolMemberSettingList._set_binding_type(type.StructType(
    'com.vmware.nsx.model.pool_member_setting_list', {
        'members': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'PoolMemberSetting'))),
    },
    PoolMemberSettingList,
    False,
    None))



class PoolUsage(VapiStruct):
    """
    Pool usage statistics in a pool.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'allocated_ids': 'allocated_ids',
                            'free_ids': 'free_ids',
                            'total_ids': 'total_ids',
                            }

    def __init__(self,
                 allocated_ids=None,
                 free_ids=None,
                 total_ids=None,
                ):
        """
        :type  allocated_ids: :class:`long` or ``None``
        :param allocated_ids: Total number of allocated IDs in a pool format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  free_ids: :class:`long` or ``None``
        :param free_ids: Total number of free IDs in a pool format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  total_ids: :class:`long` or ``None``
        :param total_ids: Total number of IDs in a pool format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.allocated_ids = allocated_ids
        self.free_ids = free_ids
        self.total_ids = total_ids
        VapiStruct.__init__(self)


PoolUsage._set_binding_type(type.StructType(
    'com.vmware.nsx.model.pool_usage', {
        'allocated_ids': type.OptionalType(type.IntegerType()),
        'free_ids': type.OptionalType(type.IntegerType()),
        'total_ids': type.OptionalType(type.IntegerType()),
    },
    PoolUsage,
    False,
    None))



class PortAttacher(VapiStruct):
    """
    VM or vmknic entity attached to LogicalPort

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'entity': 'entity',
                            'host': 'host',
                            }

    def __init__(self,
                 entity=None,
                 host=None,
                ):
        """
        :type  entity: :class:`str` or ``None``
        :param entity: This is a vmknic name if the attacher is vmknic. Otherwise, it is
            full path of the attached VM's config file
        :type  host: :class:`str` or ``None``
        :param host: TransportNode on which the attacher resides
        """
        self.entity = entity
        self.host = host
        VapiStruct.__init__(self)


PortAttacher._set_binding_type(type.StructType(
    'com.vmware.nsx.model.port_attacher', {
        'entity': type.OptionalType(type.StringType()),
        'host': type.OptionalType(type.StringType()),
    },
    PortAttacher,
    False,
    None))



class PortConnectionBMEntities(VapiStruct):
    """
    Port Connection Bare Metal Entities

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'dst_port': 'dst_port',
                            'src_port': 'src_port',
                            }

    def __init__(self,
                 dst_port=None,
                 src_port=None,
                ):
        """
        :type  dst_port: :class:`LogicalPort` or ``None``
        :param dst_port: 
        :type  src_port: :class:`LogicalPort` or ``None``
        :param src_port: 
        """
        self.dst_port = dst_port
        self.src_port = src_port
        VapiStruct.__init__(self)


PortConnectionBMEntities._set_binding_type(type.StructType(
    'com.vmware.nsx.model.port_connection_BM_entities', {
        'dst_port': type.OptionalType(type.ReferenceType(__name__, 'LogicalPort')),
        'src_port': type.OptionalType(type.ReferenceType(__name__, 'LogicalPort')),
    },
    PortConnectionBMEntities,
    False,
    None))



class PortConnectionContainersEntities(VapiStruct):
    """
    Port Connection Containers Entities

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'logical_ports': 'logical_ports',
                            }

    def __init__(self,
                 logical_ports=None,
                ):
        """
        :type  logical_ports: :class:`list` of :class:`LogicalPort` or ``None``
        :param logical_ports: 
        """
        self.logical_ports = logical_ports
        VapiStruct.__init__(self)


PortConnectionContainersEntities._set_binding_type(type.StructType(
    'com.vmware.nsx.model.port_connection_containers_entities', {
        'logical_ports': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'LogicalPort'))),
    },
    PortConnectionContainersEntities,
    False,
    None))



class PortConnectionEdgeNodeGroup(VapiStruct):
    """
    Collection of edge nodes backing a logical router

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'id': 'id',
                            'resource': 'resource',
                            'edge_nodes': 'edge_nodes',
                            'logical_router_id': 'logical_router_id',
                            }

    def __init__(self,
                 id=None,
                 resource=None,
                 edge_nodes=None,
                 logical_router_id=None,
                ):
        """
        :type  id: :class:`str` or ``None``
        :param id: Resource ID is mapped to this. (ID is Generated for Edge node
            groups, since resource will be null)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  resource: :class:`ManagedResource` or ``None``
        :param resource: Resource reference with details of the entity
        :type  edge_nodes: :class:`list` of :class:`TransportNode` or ``None``
        :param edge_nodes: 
        :type  logical_router_id: :class:`str` or ``None``
        :param logical_router_id: Id of the logical router
        """
        self.id = id
        self.resource = resource
        self.edge_nodes = edge_nodes
        self.logical_router_id = logical_router_id
        VapiStruct.__init__(self)


PortConnectionEdgeNodeGroup._set_binding_type(type.StructType(
    'com.vmware.nsx.model.port_connection_edge_node_group', {
        'id': type.OptionalType(type.StringType()),
        'resource': type.OptionalType(type.ReferenceType(__name__, 'ManagedResource')),
        'edge_nodes': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'TransportNode'))),
        'logical_router_id': type.OptionalType(type.StringType()),
    },
    PortConnectionEdgeNodeGroup,
    False,
    None))



class PortConnectionEntities(VapiStruct):
    """
    Port Connection Entities (to help draw a visual picture of entities between
    two ports)

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'containers': 'containers',
                            'edge_node_groups': 'edge_node_groups',
                            'errors': 'errors',
                            'hypervisors': 'hypervisors',
                            'logical_switches': 'logical_switches',
                            'physical_hosts': 'physical_hosts',
                            'routers': 'routers',
                            'tunnels': 'tunnels',
                            'vms': 'vms',
                            }

    def __init__(self,
                 containers=None,
                 edge_node_groups=None,
                 errors=None,
                 hypervisors=None,
                 logical_switches=None,
                 physical_hosts=None,
                 routers=None,
                 tunnels=None,
                 vms=None,
                ):
        """
        :type  containers: :class:`PortConnectionContainersEntities` or ``None``
        :param containers: 
        :type  edge_node_groups: :class:`list` of :class:`PortConnectionEdgeNodeGroup` or ``None``
        :param edge_node_groups: 
        :type  errors: :class:`list` of :class:`PortConnectionError` or ``None``
        :param errors: 
        :type  hypervisors: :class:`list` of :class:`PortConnectionHypervisor` or ``None``
        :param hypervisors: 
        :type  logical_switches: :class:`list` of :class:`PortConnectionLogicalSwitch` or ``None``
        :param logical_switches: 
        :type  physical_hosts: :class:`PortConnectionBMEntities` or ``None``
        :param physical_hosts: 
        :type  routers: :class:`list` of :class:`PortConnectionRouter` or ``None``
        :param routers: 
        :type  tunnels: :class:`list` of :class:`PortConnectionTunnel` or ``None``
        :param tunnels: 
        :type  vms: :class:`list` of :class:`VirtualMachine` or ``None``
        :param vms: 
        """
        self.containers = containers
        self.edge_node_groups = edge_node_groups
        self.errors = errors
        self.hypervisors = hypervisors
        self.logical_switches = logical_switches
        self.physical_hosts = physical_hosts
        self.routers = routers
        self.tunnels = tunnels
        self.vms = vms
        VapiStruct.__init__(self)


PortConnectionEntities._set_binding_type(type.StructType(
    'com.vmware.nsx.model.port_connection_entities', {
        'containers': type.OptionalType(type.ReferenceType(__name__, 'PortConnectionContainersEntities')),
        'edge_node_groups': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'PortConnectionEdgeNodeGroup'))),
        'errors': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'PortConnectionError'))),
        'hypervisors': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'PortConnectionHypervisor'))),
        'logical_switches': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'PortConnectionLogicalSwitch'))),
        'physical_hosts': type.OptionalType(type.ReferenceType(__name__, 'PortConnectionBMEntities')),
        'routers': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'PortConnectionRouter'))),
        'tunnels': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'PortConnectionTunnel'))),
        'vms': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'VirtualMachine'))),
    },
    PortConnectionEntities,
    False,
    None))



class PortConnectionEntity(VapiStruct):
    """
    Port Connection Entity

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'id': 'id',
                            'resource': 'resource',
                            }

    def __init__(self,
                 id=None,
                 resource=None,
                ):
        """
        :type  id: :class:`str` or ``None``
        :param id: Resource ID is mapped to this. (ID is Generated for Edge node
            groups, since resource will be null)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  resource: :class:`ManagedResource` or ``None``
        :param resource: Resource reference with details of the entity
        """
        self.id = id
        self.resource = resource
        VapiStruct.__init__(self)


PortConnectionEntity._set_binding_type(type.StructType(
    'com.vmware.nsx.model.port_connection_entity', {
        'id': type.OptionalType(type.StringType()),
        'resource': type.OptionalType(type.ReferenceType(__name__, 'ManagedResource')),
    },
    PortConnectionEntity,
    False,
    None))



class PortConnectionError(VapiStruct):
    """
    Errors encountered while fetching entities in the forwarding path

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'entity_type': 'entity_type',
                            'error_details': 'error_details',
                            'error_summary': 'error_summary',
                            }

    def __init__(self,
                 entity_type=None,
                 error_details=None,
                 error_summary=None,
                ):
        """
        :type  entity_type: :class:`str` or ``None``
        :param entity_type: 
        :type  error_details: :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param error_details: 
        :type  error_summary: :class:`str` or ``None``
        :param error_summary: 
        """
        self.entity_type = entity_type
        self.error_details = error_details
        self.error_summary = error_summary
        VapiStruct.__init__(self)


PortConnectionError._set_binding_type(type.StructType(
    'com.vmware.nsx.model.port_connection_error', {
        'entity_type': type.OptionalType(type.StringType()),
        'error_details': type.OptionalType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct)),
        'error_summary': type.OptionalType(type.StringType()),
    },
    PortConnectionError,
    False,
    None))



class PortConnectionHypervisor(VapiStruct):
    """
    Port Connection Hypervisor/Transport Node Entity

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'id': 'id',
                            'resource': 'resource',
                            'neighbors_list': 'neighbors_list',
                            'pnics': 'pnics',
                            'pnics_list': 'pnics_list',
                            'profiles': 'profiles',
                            }

    def __init__(self,
                 id=None,
                 resource=None,
                 neighbors_list=None,
                 pnics=None,
                 pnics_list=None,
                 profiles=None,
                ):
        """
        :type  id: :class:`str` or ``None``
        :param id: Resource ID is mapped to this. (ID is Generated for Edge node
            groups, since resource will be null)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  resource: :class:`ManagedResource` or ``None``
        :param resource: Resource reference with details of the entity
        :type  neighbors_list: :class:`list` of :class:`InterfaceNeighborProperties` or ``None``
        :param neighbors_list: 
        :type  pnics: :class:`list` of :class:`Pnic` or ``None``
        :param pnics: 
        :type  pnics_list: :class:`list` of :class:`NodeInterfaceProperties` or ``None``
        :param pnics_list: 
        :type  profiles: :class:`list` of :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param profiles: 
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`BaseHostSwitchProfile`. When methods return a value of this
            class as a return value, the attribute will contain all the
            attributes defined in :class:`BaseHostSwitchProfile`.
        """
        self.id = id
        self.resource = resource
        self.neighbors_list = neighbors_list
        self.pnics = pnics
        self.pnics_list = pnics_list
        self.profiles = profiles
        VapiStruct.__init__(self)


PortConnectionHypervisor._set_binding_type(type.StructType(
    'com.vmware.nsx.model.port_connection_hypervisor', {
        'id': type.OptionalType(type.StringType()),
        'resource': type.OptionalType(type.ReferenceType(__name__, 'ManagedResource')),
        'neighbors_list': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'InterfaceNeighborProperties'))),
        'pnics': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Pnic'))),
        'pnics_list': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NodeInterfaceProperties'))),
        'profiles': type.OptionalType(type.ListType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'BaseHostSwitchProfile')]))),
    },
    PortConnectionHypervisor,
    False,
    None))



class PortConnectionLogicalSwitch(VapiStruct):
    """
    Port Connection Logical Switch Entity

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'id': 'id',
                            'resource': 'resource',
                            'router_ports': 'router_ports',
                            'vm_ports': 'vm_ports',
                            'vm_ports_states': 'vm_ports_states',
                            'vm_vnics': 'vm_vnics',
                            }

    def __init__(self,
                 id=None,
                 resource=None,
                 router_ports=None,
                 vm_ports=None,
                 vm_ports_states=None,
                 vm_vnics=None,
                ):
        """
        :type  id: :class:`str` or ``None``
        :param id: Resource ID is mapped to this. (ID is Generated for Edge node
            groups, since resource will be null)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  resource: :class:`ManagedResource` or ``None``
        :param resource: Resource reference with details of the entity
        :type  router_ports: :class:`list` of :class:`LogicalPort` or ``None``
        :param router_ports: Logical Ports that are attached to a router
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  vm_ports: :class:`list` of :class:`LogicalPort` or ``None``
        :param vm_ports: Logical Ports that are attached to a VIF/VM
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  vm_ports_states: :class:`list` of :class:`LogicalPortState` or ``None``
        :param vm_ports_states: States of Logical Ports that are attached to a VIF/VM
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  vm_vnics: :class:`list` of :class:`VirtualNetworkInterface` or ``None``
        :param vm_vnics: Virutal Network Interfaces that are attached to the Logical Ports
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.id = id
        self.resource = resource
        self.router_ports = router_ports
        self.vm_ports = vm_ports
        self.vm_ports_states = vm_ports_states
        self.vm_vnics = vm_vnics
        VapiStruct.__init__(self)


PortConnectionLogicalSwitch._set_binding_type(type.StructType(
    'com.vmware.nsx.model.port_connection_logical_switch', {
        'id': type.OptionalType(type.StringType()),
        'resource': type.OptionalType(type.ReferenceType(__name__, 'ManagedResource')),
        'router_ports': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'LogicalPort'))),
        'vm_ports': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'LogicalPort'))),
        'vm_ports_states': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'LogicalPortState'))),
        'vm_vnics': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'VirtualNetworkInterface'))),
    },
    PortConnectionLogicalSwitch,
    False,
    None))



class PortConnectionRouter(VapiStruct):
    """
    Port Connection Logical Router Entity

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'id': 'id',
                            'resource': 'resource',
                            'downlink_ports': 'downlink_ports',
                            'uplink_ports': 'uplink_ports',
                            }

    def __init__(self,
                 id=None,
                 resource=None,
                 downlink_ports=None,
                 uplink_ports=None,
                ):
        """
        :type  id: :class:`str` or ``None``
        :param id: Resource ID is mapped to this. (ID is Generated for Edge node
            groups, since resource will be null)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  resource: :class:`ManagedResource` or ``None``
        :param resource: Resource reference with details of the entity
        :type  downlink_ports: :class:`list` of :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param downlink_ports: Downlink ports of the Logical Router.
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`LogicalRouterPort`. When methods return a value of this
            class as a return value, the attribute will contain all the
            attributes defined in :class:`LogicalRouterPort`.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  uplink_ports: :class:`list` of :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param uplink_ports: Uplink ports of the Logical Router.
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`LogicalRouterPort`. When methods return a value of this
            class as a return value, the attribute will contain all the
            attributes defined in :class:`LogicalRouterPort`.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.id = id
        self.resource = resource
        self.downlink_ports = downlink_ports
        self.uplink_ports = uplink_ports
        VapiStruct.__init__(self)


PortConnectionRouter._set_binding_type(type.StructType(
    'com.vmware.nsx.model.port_connection_router', {
        'id': type.OptionalType(type.StringType()),
        'resource': type.OptionalType(type.ReferenceType(__name__, 'ManagedResource')),
        'downlink_ports': type.OptionalType(type.ListType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'LogicalRouterPort')]))),
        'uplink_ports': type.OptionalType(type.ListType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'LogicalRouterPort')]))),
    },
    PortConnectionRouter,
    False,
    None))



class PortConnectionTunnel(VapiStruct):
    """
    Tunnel information between two given transport nodes

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'src_node_id': 'src_node_id',
                            'tunnel_properties': 'tunnel_properties',
                            }

    def __init__(self,
                 src_node_id=None,
                 tunnel_properties=None,
                ):
        """
        :type  src_node_id: :class:`str` or ``None``
        :param src_node_id: Id of the source transport node
        :type  tunnel_properties: :class:`TunnelProperties` or ``None``
        :param tunnel_properties: Tunnel properties between the source and the destination transport
            node
        """
        self.src_node_id = src_node_id
        self.tunnel_properties = tunnel_properties
        VapiStruct.__init__(self)


PortConnectionTunnel._set_binding_type(type.StructType(
    'com.vmware.nsx.model.port_connection_tunnel', {
        'src_node_id': type.OptionalType(type.StringType()),
        'tunnel_properties': type.OptionalType(type.ReferenceType(__name__, 'TunnelProperties')),
    },
    PortConnectionTunnel,
    False,
    None))



class PortMirroringFilter(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    FILTER_ACTION_MIRROR = "MIRROR"
    """


    """
    FILTER_ACTION_DO_NOT_MIRROR = "DO_NOT_MIRROR"
    """


    """
    IP_PROTOCOL_TCP = "TCP"
    """


    """
    IP_PROTOCOL_UDP = "UDP"
    """


    """



    _canonical_to_pep_names = {
                            'dst_ips': 'dst_ips',
                            'dst_ports': 'dst_ports',
                            'filter_action': 'filter_action',
                            'ip_protocol': 'ip_protocol',
                            'src_ips': 'src_ips',
                            'src_ports': 'src_ports',
                            }

    def __init__(self,
                 dst_ips=None,
                 dst_ports=None,
                 filter_action=None,
                 ip_protocol=None,
                 src_ips=None,
                 src_ports=None,
                ):
        """
        :type  dst_ips: :class:`IPAddresses` or ``None``
        :param dst_ips: Destination IP in the form of IPAddresses, used to match the
            destination IP of a packet. If not provided, no filtering by
            destination IPs is performed.
        :type  dst_ports: :class:`str` or ``None``
        :param dst_ports: Destination port in the form of a port or port range, used to match
            the destination port of a packet. If not provided, no filtering by
            destination port is performed. format: port-or-range
        :type  filter_action: :class:`str` or ``None``
        :param filter_action: Possible values are: 
            
            * :attr:`PortMirroringFilter.FILTER_ACTION_MIRROR`
            * :attr:`PortMirroringFilter.FILTER_ACTION_DO_NOT_MIRROR`
            
            If set to MIRROR, packets will be mirrored. If set to
            DO_NOT_MIRROR, packets will not be mirrored.
        :type  ip_protocol: :class:`str` or ``None``
        :param ip_protocol: Possible values are: 
            
            * :attr:`PortMirroringFilter.IP_PROTOCOL_TCP`
            * :attr:`PortMirroringFilter.IP_PROTOCOL_UDP`
            
            The transport protocols of TCP or UDP, used to match the transport
            protocol of a packet. If not provided, no filtering by IP protocols
            is performed.
        :type  src_ips: :class:`IPAddresses` or ``None``
        :param src_ips: Source IP in the form of IPAddresses, used to match the source IP
            of a packet. If not provided, no filtering by source IPs is
            performed.
        :type  src_ports: :class:`str` or ``None``
        :param src_ports: Source port in the form of a port or port range, used to match the
            source port of a packet. If not provided, no filtering by source
            port is performed. format: port-or-range
        """
        self.dst_ips = dst_ips
        self.dst_ports = dst_ports
        self.filter_action = filter_action
        self.ip_protocol = ip_protocol
        self.src_ips = src_ips
        self.src_ports = src_ports
        VapiStruct.__init__(self)


PortMirroringFilter._set_binding_type(type.StructType(
    'com.vmware.nsx.model.port_mirroring_filter', {
        'dst_ips': type.OptionalType(type.ReferenceType(__name__, 'IPAddresses')),
        'dst_ports': type.OptionalType(type.StringType()),
        'filter_action': type.OptionalType(type.StringType()),
        'ip_protocol': type.OptionalType(type.StringType()),
        'src_ips': type.OptionalType(type.ReferenceType(__name__, 'IPAddresses')),
        'src_ports': type.OptionalType(type.StringType()),
    },
    PortMirroringFilter,
    False,
    None))



class PortMirroringSession(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    DIRECTION_INGRESS = "INGRESS"
    """


    """
    DIRECTION_EGRESS = "EGRESS"
    """


    """
    DIRECTION_BIDIRECTIONAL = "BIDIRECTIONAL"
    """


    """
    SESSION_TYPE_LOGICALPORTMIRRORSESSION = "LogicalPortMirrorSession"
    """


    """
    SESSION_TYPE_UPLINKPORTMIRRORSESSION = "UplinkPortMirrorSession"
    """


    """
    SESSION_TYPE_RSPANSRCMIRRORSESSION = "RspanSrcMirrorSession"
    """


    """
    SESSION_TYPE_RSPANDSTMIRRORSESSION = "RspanDstMirrorSession"
    """


    """
    SESSION_TYPE_LOCALPORTMIRRORSESSION = "LocalPortMirrorSession"
    """


    """
    SESSION_TYPE_LOGICALLOCALPORTMIRRORSESSION = "LogicalLocalPortMirrorSession"
    """


    """
    SESSION_TYPE_L3PORTMIRRORSESSION = "L3PortMirrorSession"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'direction': 'direction',
                            'encapsulation_vlan_id': 'encapsulation_vlan_id',
                            'mirror_destination': 'mirror_destination',
                            'mirror_sources': 'mirror_sources',
                            'port_mirroring_filters': 'port_mirroring_filters',
                            'preserve_original_vlan': 'preserve_original_vlan',
                            'session_type': 'session_type',
                            'snap_length': 'snap_length',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 direction=None,
                 encapsulation_vlan_id=None,
                 mirror_destination=None,
                 mirror_sources=None,
                 port_mirroring_filters=None,
                 preserve_original_vlan=None,
                 session_type=None,
                 snap_length=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  direction: :class:`str` or ``None``
        :param direction: Possible values are: 
            
            * :attr:`PortMirroringSession.DIRECTION_INGRESS`
            * :attr:`PortMirroringSession.DIRECTION_EGRESS`
            * :attr:`PortMirroringSession.DIRECTION_BIDIRECTIONAL`
            
             Port mirroring session direction
        :type  encapsulation_vlan_id: :class:`long` or ``None``
        :param encapsulation_vlan_id: Only for Remote SPAN Port Mirror. format: int64
        :type  mirror_destination: :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param mirror_destination: Mirror destination
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`MirrorDestination`. When methods return a value of this
            class as a return value, the attribute will contain all the
            attributes defined in :class:`MirrorDestination`.
        :type  mirror_sources: :class:`list` of :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param mirror_sources: Mirror sources
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`MirrorSource`. When methods return a value of this class as
            a return value, the attribute will contain all the attributes
            defined in :class:`MirrorSource`.
        :type  port_mirroring_filters: :class:`list` of :class:`PortMirroringFilter` or ``None``
        :param port_mirroring_filters: An array of 5-tuples used to filter packets for the mirror session,
            if not provided, all the packets will be mirrored.
        :type  preserve_original_vlan: :class:`bool` or ``None``
        :param preserve_original_vlan: Only for Remote SPAN Port Mirror. Whether to preserve original
            VLAN.
        :type  session_type: :class:`str` or ``None``
        :param session_type: Possible values are: 
            
            *
              :attr:`PortMirroringSession.SESSION_TYPE_LOGICALPORTMIRRORSESSION`
            * :attr:`PortMirroringSession.SESSION_TYPE_UPLINKPORTMIRRORSESSION`
            * :attr:`PortMirroringSession.SESSION_TYPE_RSPANSRCMIRRORSESSION`
            * :attr:`PortMirroringSession.SESSION_TYPE_RSPANDSTMIRRORSESSION`
            * :attr:`PortMirroringSession.SESSION_TYPE_LOCALPORTMIRRORSESSION`
            *
              :attr:`PortMirroringSession.SESSION_TYPE_LOGICALLOCALPORTMIRRORSESSION`
            * :attr:`PortMirroringSession.SESSION_TYPE_L3PORTMIRRORSESSION`
            
            If this property is unset, this session will be treated as
            LocalPortMirrorSession.
        :type  snap_length: :class:`long` or ``None``
        :param snap_length: If this property is set, the packet will be truncated to the
            provided length. If this property is unset, entire packet will be
            mirrored. format: int64
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.direction = direction
        self.encapsulation_vlan_id = encapsulation_vlan_id
        self.mirror_destination = mirror_destination
        self.mirror_sources = mirror_sources
        self.port_mirroring_filters = port_mirroring_filters
        self.preserve_original_vlan = preserve_original_vlan
        self.session_type = session_type
        self.snap_length = snap_length
        VapiStruct.__init__(self)


PortMirroringSession._set_binding_type(type.StructType(
    'com.vmware.nsx.model.port_mirroring_session', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'direction': type.OptionalType(type.StringType()),
        'encapsulation_vlan_id': type.OptionalType(type.IntegerType()),
        'mirror_destination': type.OptionalType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'MirrorDestination')])),
        'mirror_sources': type.OptionalType(type.ListType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'MirrorSource')]))),
        'port_mirroring_filters': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'PortMirroringFilter'))),
        'preserve_original_vlan': type.OptionalType(type.BooleanType()),
        'session_type': type.OptionalType(type.StringType()),
        'snap_length': type.OptionalType(type.IntegerType()),
    },
    PortMirroringSession,
    False,
    None))



class PortMirroringSessionListResult(VapiStruct):
    """
    Mirror session queries result

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`PortMirroringSession` or ``None``
        :param results: Port mirroring session results
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


PortMirroringSessionListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.port_mirroring_session_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'PortMirroringSession'))),
    },
    PortMirroringSessionListResult,
    False,
    None))



class PortMirroringSwitchingProfile(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "PortMirroringSwitchingProfile"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    DIRECTION_INGRESS = "INGRESS"
    """


    """
    DIRECTION_EGRESS = "EGRESS"
    """


    """
    DIRECTION_BIDIRECTIONAL = "BIDIRECTIONAL"
    """


    """



    _canonical_to_pep_names = {
                            'destinations': 'destinations',
                            'direction': 'direction',
                            'key': 'key',
                            'snap_length': 'snap_length',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'required_capabilities': 'required_capabilities',
                            }

    def __init__(self,
                 destinations=None,
                 direction=None,
                 key=None,
                 snap_length=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='PortMirroringSwitchingProfile',
                 tags=None,
                 required_capabilities=None,
                ):
        """
        :type  destinations: :class:`list` of :class:`str` or ``None``
        :param destinations: List of destination addresses format: ip
        :type  direction: :class:`str` or ``None``
        :param direction: Possible values are: 
            
            * :attr:`PortMirroringSwitchingProfile.DIRECTION_INGRESS`
            * :attr:`PortMirroringSwitchingProfile.DIRECTION_EGRESS`
            * :attr:`PortMirroringSwitchingProfile.DIRECTION_BIDIRECTIONAL`
            
             port mirroring direction
        :type  key: :class:`long` or ``None``
        :param key: User-configurable 32-bit key format: int64
        :type  snap_length: :class:`long` or ``None``
        :param snap_length: If this property not set, original package will not be truncated.
            format: int64
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: 
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  required_capabilities: :class:`list` of :class:`str` or ``None``
        :param required_capabilities: 
        """
        self.destinations = destinations
        self.direction = direction
        self.key = key
        self.snap_length = snap_length
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        self.required_capabilities = required_capabilities
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

PortMirroringSwitchingProfile._set_binding_type(type.StructType(
    'com.vmware.nsx.model.port_mirroring_switching_profile', {
        'destinations': type.OptionalType(type.ListType(type.StringType())),
        'direction': type.OptionalType(type.StringType()),
        'key': type.OptionalType(type.IntegerType()),
        'snap_length': type.OptionalType(type.IntegerType()),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'required_capabilities': type.OptionalType(type.ListType(type.StringType())),
    },
    PortMirroringSwitchingProfile,
    False,
    None))



class PortStatus(VapiStruct):
    """
    indicates if the RabbitMQ management port is set or not

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'enabled': 'enabled',
                            }

    def __init__(self,
                 enabled=None,
                ):
        """
        :type  enabled: :class:`bool` or ``None``
        :param enabled: indicates if the RabbitMQ management port is set or not
        """
        self.enabled = enabled
        VapiStruct.__init__(self)


PortStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.port_status', {
        'enabled': type.OptionalType(type.BooleanType()),
    },
    PortStatus,
    False,
    None))



class PreconfiguredEndpoint(VapiStruct):
    """
    Tunnel endpoint configuration of preconfigured host switch

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'device_name': 'device_name',
                            }

    def __init__(self,
                 device_name=None,
                ):
        """
        :type  device_name: :class:`str` or ``None``
        :param device_name: Name of the virtual tunnel endpoint
        """
        self.device_name = device_name
        VapiStruct.__init__(self)


PreconfiguredEndpoint._set_binding_type(type.StructType(
    'com.vmware.nsx.model.preconfigured_endpoint', {
        'device_name': type.OptionalType(type.StringType()),
    },
    PreconfiguredEndpoint,
    False,
    None))



class PreconfiguredHostSwitch(VapiStruct):
    """
    Preconfigured host switch is used for manually configured transport node.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'endpoints': 'endpoints',
                            'host_switch_id': 'host_switch_id',
                            'transport_zone_endpoints': 'transport_zone_endpoints',
                            }

    def __init__(self,
                 endpoints=None,
                 host_switch_id=None,
                 transport_zone_endpoints=None,
                ):
        """
        :type  endpoints: :class:`list` of :class:`PreconfiguredEndpoint` or ``None``
        :param endpoints: List of virtual tunnel endpoints which are preconfigured on this
            host switch
        :type  host_switch_id: :class:`str` or ``None``
        :param host_switch_id: External Id of the preconfigured host switch.
        :type  transport_zone_endpoints: :class:`list` of :class:`TransportZoneEndPoint` or ``None``
        :param transport_zone_endpoints: List of TransportZones that are to be associated with specified
            host switch.
        """
        self.endpoints = endpoints
        self.host_switch_id = host_switch_id
        self.transport_zone_endpoints = transport_zone_endpoints
        VapiStruct.__init__(self)


PreconfiguredHostSwitch._set_binding_type(type.StructType(
    'com.vmware.nsx.model.preconfigured_host_switch', {
        'endpoints': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'PreconfiguredEndpoint'))),
        'host_switch_id': type.OptionalType(type.StringType()),
        'transport_zone_endpoints': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'TransportZoneEndPoint'))),
    },
    PreconfiguredHostSwitch,
    False,
    None))



class PreconfiguredHostSwitchSpec(VapiStruct):
    """
    Preconfigured host switch specification is used for manually configured
    transport node. It is user's responsibility to ensure correct configuration
    is provided to NSX. This type is only valid for supported KVM fabric nodes.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "PreconfiguredHostSwitchSpec"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'host_switches': 'host_switches',
                            'resource_type': 'resource_type',
                            }

    def __init__(self,
                 host_switches=None,
                 resource_type='PreconfiguredHostSwitchSpec',
                ):
        """
        :type  host_switches: :class:`list` of :class:`PreconfiguredHostSwitch` or ``None``
        :param host_switches: Preconfigured Transport Node host switches
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`HostSwitchSpec.RESOURCE_TYPE_STANDARDHOSTSWITCHSPEC`
            * :attr:`HostSwitchSpec.RESOURCE_TYPE_PRECONFIGUREDHOSTSWITCHSPEC`
        """
        self.host_switches = host_switches
        self._resource_type = resource_type
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

PreconfiguredHostSwitchSpec._set_binding_type(type.StructType(
    'com.vmware.nsx.model.preconfigured_host_switch_spec', {
        'host_switches': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'PreconfiguredHostSwitch'))),
        'resource_type': type.StringType(),
    },
    PreconfiguredHostSwitchSpec,
    False,
    None))



class PrefixConfig(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    ACTION_PERMIT = "PERMIT"
    """


    """
    ACTION_DENY = "DENY"
    """


    """



    _canonical_to_pep_names = {
                            'action': 'action',
                            'ge': 'ge',
                            'le': 'le',
                            'network': 'network',
                            }

    def __init__(self,
                 action=None,
                 ge=None,
                 le=None,
                 network=None,
                ):
        """
        :type  action: :class:`str` or ``None``
        :param action: Possible values are: 
            
            * :attr:`PrefixConfig.ACTION_PERMIT`
            * :attr:`PrefixConfig.ACTION_DENY`
            
             Action for the IPPrefix
        :type  ge: :class:`long` or ``None``
        :param ge: Greater than or equal to format: int64
        :type  le: :class:`long` or ``None``
        :param le: Less than or equal to format: int64
        :type  network: :class:`str` or ``None``
        :param network: If absent, the action applies to all addresses. format:
            ip-cidr-block
        """
        self.action = action
        self.ge = ge
        self.le = le
        self.network = network
        VapiStruct.__init__(self)


PrefixConfig._set_binding_type(type.StructType(
    'com.vmware.nsx.model.prefix_config', {
        'action': type.OptionalType(type.StringType()),
        'ge': type.OptionalType(type.IntegerType()),
        'le': type.OptionalType(type.IntegerType()),
        'network': type.OptionalType(type.StringType()),
    },
    PrefixConfig,
    False,
    None))



class Principal(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'attributes': 'attributes',
                            }

    def __init__(self,
                 attributes=None,
                ):
        """
        :type  attributes: :class:`list` of :class:`KeyValue` or ``None``
        :param attributes: Certificate list.
        """
        self.attributes = attributes
        VapiStruct.__init__(self)


Principal._set_binding_type(type.StructType(
    'com.vmware.nsx.model.principal', {
        'attributes': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'KeyValue'))),
    },
    Principal,
    False,
    None))



class PrincipalIdentity(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    PERMISSION_GROUP_READ_ONLY_API_USERS = "read_only_api_users"
    """


    """
    PERMISSION_GROUP_READ_WRITE_API_USERS = "read_write_api_users"
    """


    """
    PERMISSION_GROUP_SUPERUSERS = "superusers"
    """


    """
    PERMISSION_GROUP_UNDEFINED = "undefined"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'certificate_id': 'certificate_id',
                            'is_protected': 'is_protected',
                            'name': 'name',
                            'node_id': 'node_id',
                            'permission_group': 'permission_group',
                            'role': 'role',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 certificate_id=None,
                 is_protected=None,
                 name=None,
                 node_id=None,
                 permission_group=None,
                 role=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  certificate_id: :class:`str` or ``None``
        :param certificate_id: Id of the stored certificate. When used with the deprecated POST
            /trust-management/principal-identities API this field is required.
        :type  is_protected: :class:`bool` or ``None``
        :param is_protected: Indicator whether the entities created by this principal should be
            protected.
        :type  name: :class:`str` or ``None``
        :param name: Name of the principal.
        :type  node_id: :class:`str` or ``None``
        :param node_id: Unique node-id of a principal.
        :type  permission_group: :class:`str` or ``None``
        :param permission_group: Possible values are: 
            
            * :attr:`PrincipalIdentity.PERMISSION_GROUP_READ_ONLY_API_USERS`
            * :attr:`PrincipalIdentity.PERMISSION_GROUP_READ_WRITE_API_USERS`
            * :attr:`PrincipalIdentity.PERMISSION_GROUP_SUPERUSERS`
            * :attr:`PrincipalIdentity.PERMISSION_GROUP_UNDEFINED`
            
            Use the 'role' field instead and pass in 'auditor' for
            read_only_api_users or 'enterprise_admin' for the others.
        :type  role: :class:`str` or ``None``
        :param role: Role
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.certificate_id = certificate_id
        self.is_protected = is_protected
        self.name = name
        self.node_id = node_id
        self.permission_group = permission_group
        self.role = role
        VapiStruct.__init__(self)


PrincipalIdentity._set_binding_type(type.StructType(
    'com.vmware.nsx.model.principal_identity', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'certificate_id': type.OptionalType(type.StringType()),
        'is_protected': type.OptionalType(type.BooleanType()),
        'name': type.OptionalType(type.StringType()),
        'node_id': type.OptionalType(type.StringType()),
        'permission_group': type.OptionalType(type.StringType()),
        'role': type.OptionalType(type.StringType()),
    },
    PrincipalIdentity,
    False,
    None))



class PrincipalIdentityList(VapiStruct):
    """
    PrincipalIdentity query result

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`PrincipalIdentity` or ``None``
        :param results: PrincipalIdentity list.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


PrincipalIdentityList._set_binding_type(type.StructType(
    'com.vmware.nsx.model.principal_identity_list', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'PrincipalIdentity'))),
    },
    PrincipalIdentityList,
    False,
    None))



class PrincipalIdentityWithCertificate(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    PERMISSION_GROUP_READ_ONLY_API_USERS = "read_only_api_users"
    """


    """
    PERMISSION_GROUP_READ_WRITE_API_USERS = "read_write_api_users"
    """


    """
    PERMISSION_GROUP_SUPERUSERS = "superusers"
    """


    """
    PERMISSION_GROUP_UNDEFINED = "undefined"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'certificate_id': 'certificate_id',
                            'is_protected': 'is_protected',
                            'name': 'name',
                            'node_id': 'node_id',
                            'permission_group': 'permission_group',
                            'role': 'role',
                            'certificate_pem': 'certificate_pem',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 certificate_id=None,
                 is_protected=None,
                 name=None,
                 node_id=None,
                 permission_group=None,
                 role=None,
                 certificate_pem=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  certificate_id: :class:`str` or ``None``
        :param certificate_id: Id of the stored certificate. When used with the deprecated POST
            /trust-management/principal-identities API this field is required.
        :type  is_protected: :class:`bool` or ``None``
        :param is_protected: Indicator whether the entities created by this principal should be
            protected.
        :type  name: :class:`str` or ``None``
        :param name: Name of the principal.
        :type  node_id: :class:`str` or ``None``
        :param node_id: Unique node-id of a principal.
        :type  permission_group: :class:`str` or ``None``
        :param permission_group: Possible values are: 
            
            *
              :attr:`PrincipalIdentityWithCertificate.PERMISSION_GROUP_READ_ONLY_API_USERS`
            *
              :attr:`PrincipalIdentityWithCertificate.PERMISSION_GROUP_READ_WRITE_API_USERS`
            *
              :attr:`PrincipalIdentityWithCertificate.PERMISSION_GROUP_SUPERUSERS`
            *
              :attr:`PrincipalIdentityWithCertificate.PERMISSION_GROUP_UNDEFINED`
            
            Use the 'role' field instead and pass in 'auditor' for
            read_only_api_users or 'enterprise_admin' for the others.
        :type  role: :class:`str` or ``None``
        :param role: Role
        :type  certificate_pem: :class:`str` or ``None``
        :param certificate_pem: PEM encoding of the new certificate.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.certificate_id = certificate_id
        self.is_protected = is_protected
        self.name = name
        self.node_id = node_id
        self.permission_group = permission_group
        self.role = role
        self.certificate_pem = certificate_pem
        VapiStruct.__init__(self)


PrincipalIdentityWithCertificate._set_binding_type(type.StructType(
    'com.vmware.nsx.model.principal_identity_with_certificate', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'certificate_id': type.OptionalType(type.StringType()),
        'is_protected': type.OptionalType(type.BooleanType()),
        'name': type.OptionalType(type.StringType()),
        'node_id': type.OptionalType(type.StringType()),
        'permission_group': type.OptionalType(type.StringType()),
        'role': type.OptionalType(type.StringType()),
        'certificate_pem': type.OptionalType(type.StringType()),
    },
    PrincipalIdentityWithCertificate,
    False,
    None))



class PropertyItem(VapiStruct):
    """
    Represents a label-value pair.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    TYPE_STRING = "String"
    """


    """
    TYPE_NUMBER = "Number"
    """


    """
    TYPE_DATE = "Date"
    """


    """
    TYPE_URL = "Url"
    """


    """



    _canonical_to_pep_names = {
                            'condition': 'condition',
                            'field': 'field',
                            'heading': 'heading',
                            'label': 'label',
                            'navigation': 'navigation',
                            'render_configuration': 'render_configuration',
                            'separator': 'separator',
                            'type': 'type',
                            }

    def __init__(self,
                 condition=None,
                 field=None,
                 heading=None,
                 label=None,
                 navigation=None,
                 render_configuration=None,
                 separator=None,
                 type=None,
                ):
        """
        :type  condition: :class:`str` or ``None``
        :param condition: If the condition is met then the property will be displayed.
            Examples of expression syntax are provided under 'example_request'
            section of 'CreateWidgetConfiguration' API.
        :type  field: :class:`str` or ``None``
        :param field: Represents field value of the property.
        :type  heading: :class:`bool` or ``None``
        :param heading: Set to true if the field is a heading. Default is false.
        :type  label: :class:`Label` or ``None``
        :param label: If a field represents a heading, then label is not needed
        :type  navigation: :class:`str` or ``None``
        :param navigation: Hyperlink of the specified UI page that provides details. This will
            be linked with value of the property.
        :type  render_configuration: :class:`list` of :class:`RenderConfiguration` or ``None``
        :param render_configuration: Render configuration to be applied, if any.
        :type  separator: :class:`bool` or ``None``
        :param separator: If true, separates this property in a widget.
        :type  type: :class:`str` or ``None``
        :param type: Possible values are: 
            
            * :attr:`PropertyItem.TYPE_STRING`
            * :attr:`PropertyItem.TYPE_NUMBER`
            * :attr:`PropertyItem.TYPE_DATE`
            * :attr:`PropertyItem.TYPE_URL`
            
             Data type of the field.
        """
        self.condition = condition
        self.field = field
        self.heading = heading
        self.label = label
        self.navigation = navigation
        self.render_configuration = render_configuration
        self.separator = separator
        self.type = type
        VapiStruct.__init__(self)


PropertyItem._set_binding_type(type.StructType(
    'com.vmware.nsx.model.property_item', {
        'condition': type.OptionalType(type.StringType()),
        'field': type.OptionalType(type.StringType()),
        'heading': type.OptionalType(type.BooleanType()),
        'label': type.OptionalType(type.ReferenceType(__name__, 'Label')),
        'navigation': type.OptionalType(type.StringType()),
        'render_configuration': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'RenderConfiguration'))),
        'separator': type.OptionalType(type.BooleanType()),
        'type': type.OptionalType(type.StringType()),
    },
    PropertyItem,
    False,
    None))



class Protocol(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "Protocol"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    NAME_HTTP = "http"
    """


    """
    NAME_HTTPS = "https"
    """


    """
    NAME_SCP = "scp"
    """


    """
    NAME_SFTP = "sftp"
    """


    """



    _canonical_to_pep_names = {
                            'name': 'name',
                            }

    def __init__(self,
                 name='Protocol',
                ):
        """
        :type  name: :class:`str`
        :param name: Possible values are: 
            
            * :attr:`Protocol.NAME_HTTP`
            * :attr:`Protocol.NAME_HTTPS`
            * :attr:`Protocol.NAME_SCP`
            * :attr:`Protocol.NAME_SFTP`
            
             Protocol name
        """
        self._name = name
        VapiStruct.__init__(self)

    @property
    def name(self):
        """
        Return the discriminator value
        """
        return self._name

Protocol._set_binding_type(type.StructType(
    'com.vmware.nsx.model.protocol', {
        'name': type.StringType(),
    },
    Protocol,
    False,
    None))



class ProtocolVersion(VapiStruct):
    """
    TLS protocol version

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'enabled': 'enabled',
                            'name': 'name',
                            }

    def __init__(self,
                 enabled=None,
                 name=None,
                ):
        """
        :type  enabled: :class:`bool` or ``None``
        :param enabled: Enable status for this protocol version
        :type  name: :class:`str` or ``None``
        :param name: Name of the TLS protocol version
        """
        self.enabled = enabled
        self.name = name
        VapiStruct.__init__(self)


ProtocolVersion._set_binding_type(type.StructType(
    'com.vmware.nsx.model.protocol_version', {
        'enabled': type.OptionalType(type.BooleanType()),
        'name': type.OptionalType(type.StringType()),
    },
    ProtocolVersion,
    False,
    None))



class Proxy(VapiStruct):
    """
    Type to define the Proxy configuration.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    SCHEME_HTTP = "HTTP"
    """


    """
    SCHEME_HTTPS = "HTTPS"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'enabled': 'enabled',
                            'host': 'host',
                            'password': 'password',
                            'port': 'port',
                            'scheme': 'scheme',
                            'username': 'username',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 enabled=None,
                 host=None,
                 password=None,
                 port=None,
                 scheme=None,
                 username=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  enabled: :class:`bool` or ``None``
        :param enabled: Flag to indicate if proxy is enabled. When set to true, a scheme,
            host and port must be provided.
        :type  host: :class:`str` or ``None``
        :param host: Specify the fully qualified domain name, or ip address, of the
            proxy server. format: hostname-or-ip
        :type  password: :class:`str` or ``None``
        :param password: Specify the password used to authenticate with the proxy server, if
            required.
        :type  port: :class:`long` or ``None``
        :param port: Specify the port of the proxy server. format: int32
        :type  scheme: :class:`str` or ``None``
        :param scheme: Possible values are: 
            
            * :attr:`Proxy.SCHEME_HTTP`
            * :attr:`Proxy.SCHEME_HTTPS`
            
            The scheme accepted by the proxy server. Specify one of HTTP and
            HTTPS.
        :type  username: :class:`str` or ``None``
        :param username: Specify the user name used to authenticate with the proxy server,
            if required.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.enabled = enabled
        self.host = host
        self.password = password
        self.port = port
        self.scheme = scheme
        self.username = username
        VapiStruct.__init__(self)


Proxy._set_binding_type(type.StructType(
    'com.vmware.nsx.model.proxy', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'enabled': type.OptionalType(type.BooleanType()),
        'host': type.OptionalType(type.StringType()),
        'password': type.OptionalType(type.StringType()),
        'port': type.OptionalType(type.IntegerType()),
        'scheme': type.OptionalType(type.StringType()),
        'username': type.OptionalType(type.StringType()),
    },
    Proxy,
    False,
    None))



class PublicCloudGatewayNode(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'allocation_list': 'allocation_list',
                            'deployment_config': 'deployment_config',
                            'deployment_type': 'deployment_type',
                            'node_settings': 'node_settings',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'discovered_ip_addresses': 'discovered_ip_addresses',
                            'external_id': 'external_id',
                            'fqdn': 'fqdn',
                            'ip_addresses': 'ip_addresses',
                            }

    def __init__(self,
                 allocation_list=None,
                 deployment_config=None,
                 deployment_type=None,
                 node_settings=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 discovered_ip_addresses=None,
                 external_id=None,
                 fqdn=None,
                 ip_addresses=None,
                ):
        """
        :type  allocation_list: :class:`list` of :class:`str` or ``None``
        :param allocation_list: List of logical router ids to which this edge node is allocated.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  deployment_config: :class:`EdgeNodeDeploymentConfig` or ``None``
        :param deployment_config: When this configuration is specified, edge fabric node of
            deployment_type VIRTUAL_MACHINE will be deployed and registered
            with MP.
        :type  deployment_type: :class:`str` or ``None``
        :param deployment_type: Possible values are: 
            
            * :attr:`EdgeNode.DEPLOYMENT_TYPE_VIRTUAL_MACHINE`
            * :attr:`EdgeNode.DEPLOYMENT_TYPE_PHYSICAL_MACHINE`
            * :attr:`EdgeNode.DEPLOYMENT_TYPE_UNKNOWN`
            
             Supported edge deployment type.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  node_settings: :class:`EdgeNodeSettings` or ``None``
        :param node_settings: Reports the current configuration of the SSH, DHS, NTP and host
            name on this edge node. The deployment_config property is used
            during deployment and this counterpart property shows current
            values.
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Fabric node type, for example 'HostNode', 'EdgeNode' or
            'PublicCloudGatewayNode'
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  discovered_ip_addresses: :class:`list` of :class:`str` or ``None``
        :param discovered_ip_addresses: Discovered IP Addresses of the fabric node, version 4 or 6 format:
            ip
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  external_id: :class:`str` or ``None``
        :param external_id: ID of the Node maintained on the Node and used to recognize the
            Node
        :type  fqdn: :class:`str` or ``None``
        :param fqdn: Fully qualified domain name of the fabric node
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  ip_addresses: :class:`list` of :class:`str` or ``None``
        :param ip_addresses: IP Addresses of the Node, version 4 or 6. This property is
            mandatory for all nodes except for automatic deployment of edge
            virtual machine node. For automatic deployment, the ip address from
            management_port_subnets property will be considered. format: ip
        """
        self.allocation_list = allocation_list
        self.deployment_config = deployment_config
        self.deployment_type = deployment_type
        self.node_settings = node_settings
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        self.discovered_ip_addresses = discovered_ip_addresses
        self.external_id = external_id
        self.fqdn = fqdn
        self.ip_addresses = ip_addresses
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

PublicCloudGatewayNode._set_binding_type(type.StructType(
    'com.vmware.nsx.model.public_cloud_gateway_node', {
        'allocation_list': type.OptionalType(type.ListType(type.StringType())),
        'deployment_config': type.OptionalType(type.ReferenceType(__name__, 'EdgeNodeDeploymentConfig')),
        'deployment_type': type.OptionalType(type.StringType()),
        'node_settings': type.OptionalType(type.ReferenceType(__name__, 'EdgeNodeSettings')),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'discovered_ip_addresses': type.OptionalType(type.ListType(type.StringType())),
        'external_id': type.OptionalType(type.StringType()),
        'fqdn': type.OptionalType(type.StringType()),
        'ip_addresses': type.OptionalType(type.ListType(type.StringType())),
    },
    PublicCloudGatewayNode,
    False,
    None))



class QosBaseRateShaper(VapiStruct):
    """
    A shaper configuration entry that specifies type and metrics

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "QosBaseRateShaper"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    RESOURCE_TYPE_INGRESSRATESHAPER = "IngressRateShaper"
    """


    """
    RESOURCE_TYPE_INGRESSBROADCASTRATESHAPER = "IngressBroadcastRateShaper"
    """


    """
    RESOURCE_TYPE_EGRESSRATESHAPER = "EgressRateShaper"
    """


    """



    _canonical_to_pep_names = {
                            'enabled': 'enabled',
                            'resource_type': 'resource_type',
                            }

    def __init__(self,
                 enabled=None,
                 resource_type='QosBaseRateShaper',
                ):
        """
        :type  enabled: :class:`bool` or ``None``
        :param enabled: 
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`QosBaseRateShaper.RESOURCE_TYPE_INGRESSRATESHAPER`
            *
              :attr:`QosBaseRateShaper.RESOURCE_TYPE_INGRESSBROADCASTRATESHAPER`
            * :attr:`QosBaseRateShaper.RESOURCE_TYPE_EGRESSRATESHAPER`
        """
        self.enabled = enabled
        self._resource_type = resource_type
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

QosBaseRateShaper._set_binding_type(type.StructType(
    'com.vmware.nsx.model.qos_base_rate_shaper', {
        'enabled': type.OptionalType(type.BooleanType()),
        'resource_type': type.StringType(),
    },
    QosBaseRateShaper,
    False,
    None))



class QosSwitchingProfile(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "QosSwitchingProfile"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'class_of_service': 'class_of_service',
                            'dscp': 'dscp',
                            'shaper_configuration': 'shaper_configuration',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'required_capabilities': 'required_capabilities',
                            }

    def __init__(self,
                 class_of_service=None,
                 dscp=None,
                 shaper_configuration=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='QosSwitchingProfile',
                 tags=None,
                 required_capabilities=None,
                ):
        """
        :type  class_of_service: :class:`long` or ``None``
        :param class_of_service: Class of service format: int32
        :type  dscp: :class:`Dscp` or ``None``
        :param dscp: 
        :type  shaper_configuration: :class:`list` of :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param shaper_configuration: 
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`QosBaseRateShaper`. When methods return a value of this
            class as a return value, the attribute will contain all the
            attributes defined in :class:`QosBaseRateShaper`.
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: 
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  required_capabilities: :class:`list` of :class:`str` or ``None``
        :param required_capabilities: 
        """
        self.class_of_service = class_of_service
        self.dscp = dscp
        self.shaper_configuration = shaper_configuration
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        self.required_capabilities = required_capabilities
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

QosSwitchingProfile._set_binding_type(type.StructType(
    'com.vmware.nsx.model.qos_switching_profile', {
        'class_of_service': type.OptionalType(type.IntegerType()),
        'dscp': type.OptionalType(type.ReferenceType(__name__, 'Dscp')),
        'shaper_configuration': type.OptionalType(type.ListType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'QosBaseRateShaper')]))),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'required_capabilities': type.OptionalType(type.ListType(type.StringType())),
    },
    QosSwitchingProfile,
    False,
    None))



class RAConfig(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'hop_limit': 'hop_limit',
                            'prefix_lifetime': 'prefix_lifetime',
                            'prefix_preferred_time': 'prefix_preferred_time',
                            'ra_interval': 'ra_interval',
                            'router_lifetime': 'router_lifetime',
                            }

    def __init__(self,
                 hop_limit=None,
                 prefix_lifetime=None,
                 prefix_preferred_time=None,
                 ra_interval=None,
                 router_lifetime=None,
                ):
        """
        :type  hop_limit: :class:`long` or ``None``
        :param hop_limit: The maximum number of hops through which packets can pass before
            being discarded. format: int64
        :type  prefix_lifetime: :class:`long` or ``None``
        :param prefix_lifetime: The time interval in seconds, in which the prefix is advertised as
            valid. format: int64
        :type  prefix_preferred_time: :class:`long` or ``None``
        :param prefix_preferred_time: The time interval in seconds, in which the prefix is advertised as
            preferred. format: int64
        :type  ra_interval: :class:`long` or ``None``
        :param ra_interval: Interval between 2 Router advertisement in seconds. format: int64
        :type  router_lifetime: :class:`long` or ``None``
        :param router_lifetime: Router lifetime value in seconds. A value of 0 indicates the router
            is not a default router for the receiving end. Any other value in
            this field specifies the lifetime, in seconds, associated with this
            router as a default router. format: int64
        """
        self.hop_limit = hop_limit
        self.prefix_lifetime = prefix_lifetime
        self.prefix_preferred_time = prefix_preferred_time
        self.ra_interval = ra_interval
        self.router_lifetime = router_lifetime
        VapiStruct.__init__(self)


RAConfig._set_binding_type(type.StructType(
    'com.vmware.nsx.model.RA_config', {
        'hop_limit': type.OptionalType(type.IntegerType()),
        'prefix_lifetime': type.OptionalType(type.IntegerType()),
        'prefix_preferred_time': type.OptionalType(type.IntegerType()),
        'ra_interval': type.OptionalType(type.IntegerType()),
        'router_lifetime': type.OptionalType(type.IntegerType()),
    },
    RAConfig,
    False,
    None))



class RaDNSConfig(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'dns_server': 'dns_server',
                            'dns_server_lifetime': 'dns_server_lifetime',
                            'domain_name': 'domain_name',
                            'domain_name_lifetime': 'domain_name_lifetime',
                            }

    def __init__(self,
                 dns_server=None,
                 dns_server_lifetime=None,
                 domain_name=None,
                 domain_name_lifetime=None,
                ):
        """
        :type  dns_server: :class:`list` of :class:`str` or ``None``
        :param dns_server: DNS server. format: ipv6
        :type  dns_server_lifetime: :class:`long` or ``None``
        :param dns_server_lifetime: Lifetime of DNS server in milliseconds format: int64
        :type  domain_name: :class:`list` of :class:`str` or ``None``
        :param domain_name: Domain name in RA message.
        :type  domain_name_lifetime: :class:`long` or ``None``
        :param domain_name_lifetime: Lifetime of Domain names in milliseconds format: int64
        """
        self.dns_server = dns_server
        self.dns_server_lifetime = dns_server_lifetime
        self.domain_name = domain_name
        self.domain_name_lifetime = domain_name_lifetime
        VapiStruct.__init__(self)


RaDNSConfig._set_binding_type(type.StructType(
    'com.vmware.nsx.model.ra_DNS_config', {
        'dns_server': type.OptionalType(type.ListType(type.StringType())),
        'dns_server_lifetime': type.OptionalType(type.IntegerType()),
        'domain_name': type.OptionalType(type.ListType(type.StringType())),
        'domain_name_lifetime': type.OptionalType(type.IntegerType()),
    },
    RaDNSConfig,
    False,
    None))



class RateLimits(VapiStruct):
    """
    Enables traffic limit for incoming/outgoing broadcast and multicast
    packets. Use 0 to disable rate limiting for a specific traffic type

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'enabled': 'enabled',
                            'rx_broadcast': 'rx_broadcast',
                            'rx_multicast': 'rx_multicast',
                            'tx_broadcast': 'tx_broadcast',
                            'tx_multicast': 'tx_multicast',
                            }

    def __init__(self,
                 enabled=None,
                 rx_broadcast=None,
                 rx_multicast=None,
                 tx_broadcast=None,
                 tx_multicast=None,
                ):
        """
        :type  enabled: :class:`bool` or ``None``
        :param enabled: Whether rate limiting is enabled
        :type  rx_broadcast: :class:`long` or ``None``
        :param rx_broadcast: Incoming broadcast traffic limit in packets per second format:
            int32
        :type  rx_multicast: :class:`long` or ``None``
        :param rx_multicast: Incoming multicast traffic limit in packets per second format:
            int32
        :type  tx_broadcast: :class:`long` or ``None``
        :param tx_broadcast: Outgoing broadcast traffic limit in packets per second format:
            int32
        :type  tx_multicast: :class:`long` or ``None``
        :param tx_multicast: Outgoing multicast traffic limit in packets per second format:
            int32
        """
        self.enabled = enabled
        self.rx_broadcast = rx_broadcast
        self.rx_multicast = rx_multicast
        self.tx_broadcast = tx_broadcast
        self.tx_multicast = tx_multicast
        VapiStruct.__init__(self)


RateLimits._set_binding_type(type.StructType(
    'com.vmware.nsx.model.rate_limits', {
        'enabled': type.OptionalType(type.BooleanType()),
        'rx_broadcast': type.OptionalType(type.IntegerType()),
        'rx_multicast': type.OptionalType(type.IntegerType()),
        'tx_broadcast': type.OptionalType(type.IntegerType()),
        'tx_multicast': type.OptionalType(type.IntegerType()),
    },
    RateLimits,
    False,
    None))



class RealizationStateBarrierConfig(VapiStruct):
    """
    The configuration data for setting the global realization state barrier

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            'interval': 'interval',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 interval=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  interval: :class:`long` or ``None``
        :param interval: The interval in milliseconds used for auto incrementing the barrier
            number format: int64
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.interval = interval
        VapiStruct.__init__(self)


RealizationStateBarrierConfig._set_binding_type(type.StructType(
    'com.vmware.nsx.model.realization_state_barrier_config', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        'interval': type.OptionalType(type.IntegerType()),
    },
    RealizationStateBarrierConfig,
    False,
    None))



class RedistributionConfig(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'bgp_enabled': 'bgp_enabled',
                            'logical_router_id': 'logical_router_id',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 bgp_enabled=None,
                 logical_router_id=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  bgp_enabled: :class:`bool` or ``None``
        :param bgp_enabled: Flag to enable redistribution for BGP as destinationProtocol
        :type  logical_router_id: :class:`str` or ``None``
        :param logical_router_id: Logical router id
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.bgp_enabled = bgp_enabled
        self.logical_router_id = logical_router_id
        VapiStruct.__init__(self)


RedistributionConfig._set_binding_type(type.StructType(
    'com.vmware.nsx.model.redistribution_config', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'bgp_enabled': type.OptionalType(type.BooleanType()),
        'logical_router_id': type.OptionalType(type.StringType()),
    },
    RedistributionConfig,
    False,
    None))



class RedistributionRule(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    ADDRESS_FAMILY_IPV4 = "IPV4"
    """


    """
    ADDRESS_FAMILY_IPV6 = "IPV6"
    """


    """
    ADDRESS_FAMILY_IPV4_AND_IPV6 = "IPV4_AND_IPV6"
    """


    """
    DESTINATION_STATIC = "STATIC"
    """


    """
    DESTINATION_T0_STATIC = "T0_STATIC"
    """


    """
    DESTINATION_NSX_CONNECTED = "NSX_CONNECTED"
    """


    """
    DESTINATION_T0_CONNECTED = "T0_CONNECTED"
    """


    """
    DESTINATION_NSX_STATIC = "NSX_STATIC"
    """


    """
    DESTINATION_T1_STATIC = "T1_STATIC"
    """


    """
    DESTINATION_T0_UPLINK = "T0_UPLINK"
    """


    """
    DESTINATION_T0_DOWNLINK = "T0_DOWNLINK"
    """


    """
    DESTINATION_T0_ROUTER_LINK = "T0_ROUTER_LINK"
    """


    """
    DESTINATION_T0_CSP = "T0_CSP"
    """


    """
    DESTINATION_T0_LOOPBACK = "T0_LOOPBACK"
    """


    """
    DESTINATION_T0_DNS_FORWARDER_IP = "T0_DNS_FORWARDER_IP"
    """


    """
    DESTINATION_T0_IPSEC_LOCAL_IP = "T0_IPSEC_LOCAL_IP"
    """


    """
    DESTINATION_TIER0_NAT = "TIER0_NAT"
    """


    """
    DESTINATION_T0_NAT = "T0_NAT"
    """


    """
    DESTINATION_TIER1_NAT = "TIER1_NAT"
    """


    """
    DESTINATION_T1_NAT = "T1_NAT"
    """


    """
    DESTINATION_TIER1_LB_VIP = "TIER1_LB_VIP"
    """


    """
    DESTINATION_T1_LB_VIP = "T1_LB_VIP"
    """


    """
    DESTINATION_TIER1_LB_SNAT = "TIER1_LB_SNAT"
    """


    """
    DESTINATION_T1_LB_SNAT = "T1_LB_SNAT"
    """


    """
    DESTINATION_T1_DNS_FORWARDER_IP = "T1_DNS_FORWARDER_IP"
    """


    """
    DESTINATION_T1_CONNECTED = "T1_CONNECTED"
    """


    """
    DESTINATION_T1_DOWNLINK = "T1_DOWNLINK"
    """


    """
    DESTINATION_T1_CSP = "T1_CSP"
    """


    """
    DESTINATION_BGP = "BGP"
    """


    """
    DESTINATION_T1_IPSEC_LOCAL_IP = "T1_IPSEC_LOCAL_IP"
    """


    """
    DESTINATION_T0_EVPN_TEP_IP = "T0_EVPN_TEP_IP"
    """


    """
    SOURCES_STATIC = "STATIC"
    """


    """
    SOURCES_T0_STATIC = "T0_STATIC"
    """


    """
    SOURCES_NSX_CONNECTED = "NSX_CONNECTED"
    """


    """
    SOURCES_T0_CONNECTED = "T0_CONNECTED"
    """


    """
    SOURCES_NSX_STATIC = "NSX_STATIC"
    """


    """
    SOURCES_T1_STATIC = "T1_STATIC"
    """


    """
    SOURCES_T0_UPLINK = "T0_UPLINK"
    """


    """
    SOURCES_T0_DOWNLINK = "T0_DOWNLINK"
    """


    """
    SOURCES_T0_ROUTER_LINK = "T0_ROUTER_LINK"
    """


    """
    SOURCES_T0_CSP = "T0_CSP"
    """


    """
    SOURCES_T0_LOOPBACK = "T0_LOOPBACK"
    """


    """
    SOURCES_T0_DNS_FORWARDER_IP = "T0_DNS_FORWARDER_IP"
    """


    """
    SOURCES_T0_IPSEC_LOCAL_IP = "T0_IPSEC_LOCAL_IP"
    """


    """
    SOURCES_TIER0_NAT = "TIER0_NAT"
    """


    """
    SOURCES_T0_NAT = "T0_NAT"
    """


    """
    SOURCES_TIER1_NAT = "TIER1_NAT"
    """


    """
    SOURCES_T1_NAT = "T1_NAT"
    """


    """
    SOURCES_TIER1_LB_VIP = "TIER1_LB_VIP"
    """


    """
    SOURCES_T1_LB_VIP = "T1_LB_VIP"
    """


    """
    SOURCES_TIER1_LB_SNAT = "TIER1_LB_SNAT"
    """


    """
    SOURCES_T1_LB_SNAT = "T1_LB_SNAT"
    """


    """
    SOURCES_T1_DNS_FORWARDER_IP = "T1_DNS_FORWARDER_IP"
    """


    """
    SOURCES_T1_CONNECTED = "T1_CONNECTED"
    """


    """
    SOURCES_T1_DOWNLINK = "T1_DOWNLINK"
    """


    """
    SOURCES_T1_CSP = "T1_CSP"
    """


    """
    SOURCES_BGP = "BGP"
    """


    """
    SOURCES_T1_IPSEC_LOCAL_IP = "T1_IPSEC_LOCAL_IP"
    """


    """
    SOURCES_T0_EVPN_TEP_IP = "T0_EVPN_TEP_IP"
    """


    """



    _canonical_to_pep_names = {
                            'address_family': 'address_family',
                            'description': 'description',
                            'destination': 'destination',
                            'display_name': 'display_name',
                            'route_map_id': 'route_map_id',
                            'sources': 'sources',
                            }

    def __init__(self,
                 address_family=None,
                 description=None,
                 destination=None,
                 display_name=None,
                 route_map_id=None,
                 sources=None,
                ):
        """
        :type  address_family: :class:`str` or ``None``
        :param address_family: Possible values are: 
            
            * :attr:`RedistributionRule.ADDRESS_FAMILY_IPV4`
            * :attr:`RedistributionRule.ADDRESS_FAMILY_IPV6`
            * :attr:`RedistributionRule.ADDRESS_FAMILY_IPV4_AND_IPV6`
            
             Address family for Route Redistribution
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description
        :type  destination: :class:`str` or ``None``
        :param destination: Possible values are: 
            
            * :attr:`RedistributionRule.DESTINATION_STATIC`
            * :attr:`RedistributionRule.DESTINATION_T0_STATIC`
            * :attr:`RedistributionRule.DESTINATION_NSX_CONNECTED`
            * :attr:`RedistributionRule.DESTINATION_T0_CONNECTED`
            * :attr:`RedistributionRule.DESTINATION_NSX_STATIC`
            * :attr:`RedistributionRule.DESTINATION_T1_STATIC`
            * :attr:`RedistributionRule.DESTINATION_T0_UPLINK`
            * :attr:`RedistributionRule.DESTINATION_T0_DOWNLINK`
            * :attr:`RedistributionRule.DESTINATION_T0_ROUTER_LINK`
            * :attr:`RedistributionRule.DESTINATION_T0_CSP`
            * :attr:`RedistributionRule.DESTINATION_T0_LOOPBACK`
            * :attr:`RedistributionRule.DESTINATION_T0_DNS_FORWARDER_IP`
            * :attr:`RedistributionRule.DESTINATION_T0_IPSEC_LOCAL_IP`
            * :attr:`RedistributionRule.DESTINATION_TIER0_NAT`
            * :attr:`RedistributionRule.DESTINATION_T0_NAT`
            * :attr:`RedistributionRule.DESTINATION_TIER1_NAT`
            * :attr:`RedistributionRule.DESTINATION_T1_NAT`
            * :attr:`RedistributionRule.DESTINATION_TIER1_LB_VIP`
            * :attr:`RedistributionRule.DESTINATION_T1_LB_VIP`
            * :attr:`RedistributionRule.DESTINATION_TIER1_LB_SNAT`
            * :attr:`RedistributionRule.DESTINATION_T1_LB_SNAT`
            * :attr:`RedistributionRule.DESTINATION_T1_DNS_FORWARDER_IP`
            * :attr:`RedistributionRule.DESTINATION_T1_CONNECTED`
            * :attr:`RedistributionRule.DESTINATION_T1_DOWNLINK`
            * :attr:`RedistributionRule.DESTINATION_T1_CSP`
            * :attr:`RedistributionRule.DESTINATION_BGP`
            * :attr:`RedistributionRule.DESTINATION_T1_IPSEC_LOCAL_IP`
            * :attr:`RedistributionRule.DESTINATION_T0_EVPN_TEP_IP`
            
             Destination redistribution protocol
        :type  display_name: :class:`str` or ``None``
        :param display_name: Display name
        :type  route_map_id: :class:`str` or ``None``
        :param route_map_id: RouteMap Id for the filter
        :type  sources: :class:`list` of :class:`str` or ``None``
        :param sources: Possible values are: 
            
            * :attr:`RedistributionRule.SOURCES_STATIC`
            * :attr:`RedistributionRule.SOURCES_T0_STATIC`
            * :attr:`RedistributionRule.SOURCES_NSX_CONNECTED`
            * :attr:`RedistributionRule.SOURCES_T0_CONNECTED`
            * :attr:`RedistributionRule.SOURCES_NSX_STATIC`
            * :attr:`RedistributionRule.SOURCES_T1_STATIC`
            * :attr:`RedistributionRule.SOURCES_T0_UPLINK`
            * :attr:`RedistributionRule.SOURCES_T0_DOWNLINK`
            * :attr:`RedistributionRule.SOURCES_T0_ROUTER_LINK`
            * :attr:`RedistributionRule.SOURCES_T0_CSP`
            * :attr:`RedistributionRule.SOURCES_T0_LOOPBACK`
            * :attr:`RedistributionRule.SOURCES_T0_DNS_FORWARDER_IP`
            * :attr:`RedistributionRule.SOURCES_T0_IPSEC_LOCAL_IP`
            * :attr:`RedistributionRule.SOURCES_TIER0_NAT`
            * :attr:`RedistributionRule.SOURCES_T0_NAT`
            * :attr:`RedistributionRule.SOURCES_TIER1_NAT`
            * :attr:`RedistributionRule.SOURCES_T1_NAT`
            * :attr:`RedistributionRule.SOURCES_TIER1_LB_VIP`
            * :attr:`RedistributionRule.SOURCES_T1_LB_VIP`
            * :attr:`RedistributionRule.SOURCES_TIER1_LB_SNAT`
            * :attr:`RedistributionRule.SOURCES_T1_LB_SNAT`
            * :attr:`RedistributionRule.SOURCES_T1_DNS_FORWARDER_IP`
            * :attr:`RedistributionRule.SOURCES_T1_CONNECTED`
            * :attr:`RedistributionRule.SOURCES_T1_DOWNLINK`
            * :attr:`RedistributionRule.SOURCES_T1_CSP`
            * :attr:`RedistributionRule.SOURCES_BGP`
            * :attr:`RedistributionRule.SOURCES_T1_IPSEC_LOCAL_IP`
            * :attr:`RedistributionRule.SOURCES_T0_EVPN_TEP_IP`
            
             Array of redistribution protocols
        """
        self.address_family = address_family
        self.description = description
        self.destination = destination
        self.display_name = display_name
        self.route_map_id = route_map_id
        self.sources = sources
        VapiStruct.__init__(self)


RedistributionRule._set_binding_type(type.StructType(
    'com.vmware.nsx.model.redistribution_rule', {
        'address_family': type.OptionalType(type.StringType()),
        'description': type.OptionalType(type.StringType()),
        'destination': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'route_map_id': type.OptionalType(type.StringType()),
        'sources': type.OptionalType(type.ListType(type.StringType())),
    },
    RedistributionRule,
    False,
    None))



class RedistributionRuleList(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'logical_router_id': 'logical_router_id',
                            'rules': 'rules',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 logical_router_id=None,
                 rules=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  logical_router_id: :class:`str` or ``None``
        :param logical_router_id: Logical router id
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  rules: :class:`list` of :class:`RedistributionRule` or ``None``
        :param rules: List of redistribution rules. User needs to re-order rules to
            change the priority.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.logical_router_id = logical_router_id
        self.rules = rules
        VapiStruct.__init__(self)


RedistributionRuleList._set_binding_type(type.StructType(
    'com.vmware.nsx.model.redistribution_rule_list', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'logical_router_id': type.OptionalType(type.StringType()),
        'rules': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'RedistributionRule'))),
    },
    RedistributionRuleList,
    False,
    None))



class RegistrationToken(VapiStruct):
    """
    Appliance registration access token

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'roles': 'roles',
                            'token': 'token',
                            'user': 'user',
                            }

    def __init__(self,
                 roles=None,
                 token=None,
                 user=None,
                ):
        """
        :type  roles: :class:`list` of :class:`str` or ``None``
        :param roles: List results
        :type  token: :class:`str` or ``None``
        :param token: Access token
        :type  user: :class:`str` or ``None``
        :param user: User delegated by token
        """
        self.roles = roles
        self.token = token
        self.user = user
        VapiStruct.__init__(self)


RegistrationToken._set_binding_type(type.StructType(
    'com.vmware.nsx.model.registration_token', {
        'roles': type.OptionalType(type.ListType(type.StringType())),
        'token': type.OptionalType(type.StringType()),
        'user': type.OptionalType(type.StringType()),
    },
    RegistrationToken,
    False,
    None))



class RelatedApiError(VapiStruct):
    """
    Detailed information about a related API error

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'details': 'details',
                            'error_code': 'error_code',
                            'error_data': 'error_data',
                            'error_message': 'error_message',
                            'module_name': 'module_name',
                            }

    def __init__(self,
                 details=None,
                 error_code=None,
                 error_data=None,
                 error_message=None,
                 module_name=None,
                ):
        """
        :type  details: :class:`str` or ``None``
        :param details: Further details about the error
        :type  error_code: :class:`long` or ``None``
        :param error_code: A numeric error code format: int64
        :type  error_data: :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param error_data: Additional data about the error
        :type  error_message: :class:`str` or ``None``
        :param error_message: A description of the error
        :type  module_name: :class:`str` or ``None``
        :param module_name: The module name where the error occurred
        """
        self.details = details
        self.error_code = error_code
        self.error_data = error_data
        self.error_message = error_message
        self.module_name = module_name
        VapiStruct.__init__(self)


RelatedApiError._set_binding_type(type.StructType(
    'com.vmware.nsx.model.related_api_error', {
        'details': type.OptionalType(type.StringType()),
        'error_code': type.OptionalType(type.IntegerType()),
        'error_data': type.OptionalType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct)),
        'error_message': type.OptionalType(type.StringType()),
        'module_name': type.OptionalType(type.StringType()),
    },
    RelatedApiError,
    False,
    None))



class RemainingSupportBundleNode(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATUS_PENDING = "PENDING"
    """


    """
    STATUS_PROCESSING = "PROCESSING"
    """


    """



    _canonical_to_pep_names = {
                            'node_display_name': 'node_display_name',
                            'node_id': 'node_id',
                            'status': 'status',
                            }

    def __init__(self,
                 node_display_name=None,
                 node_id=None,
                 status=None,
                ):
        """
        :type  node_display_name: :class:`str` or ``None``
        :param node_display_name: Display name of node
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  node_id: :class:`str` or ``None``
        :param node_id: UUID of node
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  status: :class:`str` or ``None``
        :param status: Possible values are: 
            
            * :attr:`RemainingSupportBundleNode.STATUS_PENDING`
            * :attr:`RemainingSupportBundleNode.STATUS_PROCESSING`
            
             Status of node
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.node_display_name = node_display_name
        self.node_id = node_id
        self.status = status
        VapiStruct.__init__(self)


RemainingSupportBundleNode._set_binding_type(type.StructType(
    'com.vmware.nsx.model.remaining_support_bundle_node', {
        'node_display_name': type.OptionalType(type.StringType()),
        'node_id': type.OptionalType(type.StringType()),
        'status': type.OptionalType(type.StringType()),
    },
    RemainingSupportBundleNode,
    False,
    None))



class RemoteBundleUrl(VapiStruct):
    """
    URL of remote bundle which needs to be uploaded

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'url': 'url',
                            }

    def __init__(self,
                 url=None,
                ):
        """
        :type  url: :class:`str` or ``None``
        :param url: URL for uploading remote bundle
        """
        self.url = url
        VapiStruct.__init__(self)


RemoteBundleUrl._set_binding_type(type.StructType(
    'com.vmware.nsx.model.remote_bundle_url', {
        'url': type.OptionalType(type.StringType()),
    },
    RemoteBundleUrl,
    False,
    None))



class RemoteFileServer(VapiStruct):
    """
    Remote file server

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'directory_path': 'directory_path',
                            'port': 'port',
                            'protocol': 'protocol',
                            'server': 'server',
                            }

    def __init__(self,
                 directory_path=None,
                 port=None,
                 protocol=None,
                 server=None,
                ):
        """
        :type  directory_path: :class:`str` or ``None``
        :param directory_path: Remote server directory to copy bundle files to
        :type  port: :class:`long` or ``None``
        :param port: Server port format: int64
        :type  protocol: :class:`FileTransferProtocol` or ``None``
        :param protocol: Protocol to use to copy file
        :type  server: :class:`str` or ``None``
        :param server: Remote server hostname or IP address format: hostname-or-ip
        """
        self.directory_path = directory_path
        self.port = port
        self.protocol = protocol
        self.server = server
        VapiStruct.__init__(self)


RemoteFileServer._set_binding_type(type.StructType(
    'com.vmware.nsx.model.remote_file_server', {
        'directory_path': type.OptionalType(type.StringType()),
        'port': type.OptionalType(type.IntegerType()),
        'protocol': type.OptionalType(type.ReferenceType(__name__, 'FileTransferProtocol')),
        'server': type.OptionalType(type.StringType()),
    },
    RemoteFileServer,
    False,
    None))



class RemoteServerFingerprint(VapiStruct):
    """
    Remote server

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'port': 'port',
                            'server': 'server',
                            'ssh_fingerprint': 'ssh_fingerprint',
                            }

    def __init__(self,
                 port=None,
                 server=None,
                 ssh_fingerprint=None,
                ):
        """
        :type  port: :class:`long` or ``None``
        :param port: Server port format: int64
        :type  server: :class:`str` or ``None``
        :param server: Remote server hostname or IP address format: hostname-or-ip
        :type  ssh_fingerprint: :class:`str` or ``None``
        :param ssh_fingerprint: SSH fingerprint of server
        """
        self.port = port
        self.server = server
        self.ssh_fingerprint = ssh_fingerprint
        VapiStruct.__init__(self)


RemoteServerFingerprint._set_binding_type(type.StructType(
    'com.vmware.nsx.model.remote_server_fingerprint', {
        'port': type.OptionalType(type.IntegerType()),
        'server': type.OptionalType(type.StringType()),
        'ssh_fingerprint': type.OptionalType(type.StringType()),
    },
    RemoteServerFingerprint,
    False,
    None))



class RemoteServerFingerprintRequest(VapiStruct):
    """
    Remote server

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'port': 'port',
                            'server': 'server',
                            }

    def __init__(self,
                 port=None,
                 server=None,
                ):
        """
        :type  port: :class:`long` or ``None``
        :param port: Server port format: int64
        :type  server: :class:`str` or ``None``
        :param server: Remote server hostname or IP address format: hostname-or-ip
        """
        self.port = port
        self.server = server
        VapiStruct.__init__(self)


RemoteServerFingerprintRequest._set_binding_type(type.StructType(
    'com.vmware.nsx.model.remote_server_fingerprint_request', {
        'port': type.OptionalType(type.IntegerType()),
        'server': type.OptionalType(type.StringType()),
    },
    RemoteServerFingerprintRequest,
    False,
    None))



class RemoteTunnelEndpoint(VapiStruct):
    """
    Remote tunnel endpoint

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'default_gateway': 'default_gateway',
                            'device_name': 'device_name',
                            'ip': 'ip',
                            'label': 'label',
                            'mac': 'mac',
                            'subnet_mask': 'subnet_mask',
                            'vlan': 'vlan',
                            }

    def __init__(self,
                 default_gateway=None,
                 device_name=None,
                 ip=None,
                 label=None,
                 mac=None,
                 subnet_mask=None,
                 vlan=None,
                ):
        """
        :type  default_gateway: :class:`str` or ``None``
        :param default_gateway: Gateway IP format: ip
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  device_name: :class:`str` or ``None``
        :param device_name: Name of the virtual tunnel endpoint
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  ip: :class:`str` or ``None``
        :param ip: Depending upon the EndpointIpConfig used in HostSwitch, IP could be
            allocated either from DHCP (default) or from Static IP Pool.
            format: ip
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  label: :class:`long` or ``None``
        :param label: Unique label for this Endpoint format: int32
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  mac: :class:`str` or ``None``
        :param mac: MAC address format: mac-address
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  subnet_mask: :class:`str` or ``None``
        :param subnet_mask: Subnet mask format: ip
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  vlan: :class:`long` or ``None``
        :param vlan: Vlan id format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.default_gateway = default_gateway
        self.device_name = device_name
        self.ip = ip
        self.label = label
        self.mac = mac
        self.subnet_mask = subnet_mask
        self.vlan = vlan
        VapiStruct.__init__(self)


RemoteTunnelEndpoint._set_binding_type(type.StructType(
    'com.vmware.nsx.model.remote_tunnel_endpoint', {
        'default_gateway': type.OptionalType(type.StringType()),
        'device_name': type.OptionalType(type.StringType()),
        'ip': type.OptionalType(type.StringType()),
        'label': type.OptionalType(type.IntegerType()),
        'mac': type.OptionalType(type.StringType()),
        'subnet_mask': type.OptionalType(type.StringType()),
        'vlan': type.OptionalType(type.IntegerType()),
    },
    RemoteTunnelEndpoint,
    False,
    None))



class RemoteTunnelEndpointConfigState(VapiStruct):
    """
    Remote tunnel endpoint configuration state

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'endpoints': 'endpoints',
                            }

    def __init__(self,
                 endpoints=None,
                ):
        """
        :type  endpoints: :class:`list` of :class:`RemoteTunnelEndpoint` or ``None``
        :param endpoints: List of remote tunnel endpoints which are configured on this node
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.endpoints = endpoints
        VapiStruct.__init__(self)


RemoteTunnelEndpointConfigState._set_binding_type(type.StructType(
    'com.vmware.nsx.model.remote_tunnel_endpoint_config_state', {
        'endpoints': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'RemoteTunnelEndpoint'))),
    },
    RemoteTunnelEndpointConfigState,
    False,
    None))



class RemoteTunnelStatistics(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'rx': 'rx',
                            'tunnel_destination_address': 'tunnel_destination_address',
                            'tunnel_source_address': 'tunnel_source_address',
                            'tx': 'tx',
                            }

    def __init__(self,
                 rx=None,
                 tunnel_destination_address=None,
                 tunnel_source_address=None,
                 tx=None,
                ):
        """
        :type  rx: :class:`InterSitePortCounters` or ``None``
        :param rx: Total received data from remote tunnel.
        :type  tunnel_destination_address: :class:`str` or ``None``
        :param tunnel_destination_address: Ip address of remote tunnel destination. format: ip
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  tunnel_source_address: :class:`str` or ``None``
        :param tunnel_source_address: Ip address of remote tunnel source. format: ip
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  tx: :class:`InterSitePortCounters` or ``None``
        :param tx: Total sent data to remote tunnel.
        """
        self.rx = rx
        self.tunnel_destination_address = tunnel_destination_address
        self.tunnel_source_address = tunnel_source_address
        self.tx = tx
        VapiStruct.__init__(self)


RemoteTunnelStatistics._set_binding_type(type.StructType(
    'com.vmware.nsx.model.remote_tunnel_statistics', {
        'rx': type.OptionalType(type.ReferenceType(__name__, 'InterSitePortCounters')),
        'tunnel_destination_address': type.OptionalType(type.StringType()),
        'tunnel_source_address': type.OptionalType(type.StringType()),
        'tx': type.OptionalType(type.ReferenceType(__name__, 'InterSitePortCounters')),
    },
    RemoteTunnelStatistics,
    False,
    None))



class RemoteTunnelStatisticsPerSite(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'remote_site': 'remote_site',
                            'rx': 'rx',
                            'stats_per_tunnel': 'stats_per_tunnel',
                            'tx': 'tx',
                            }

    def __init__(self,
                 remote_site=None,
                 rx=None,
                 stats_per_tunnel=None,
                 tx=None,
                ):
        """
        :type  remote_site: :class:`ResourceReference` or ``None``
        :param remote_site: Remote site details.
        :type  rx: :class:`InterSitePortCounters` or ``None``
        :param rx: Total received data from remote site.
        :type  stats_per_tunnel: :class:`list` of :class:`RemoteTunnelStatistics` or ``None``
        :param stats_per_tunnel: Statistics per remote tunnel.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  tx: :class:`InterSitePortCounters` or ``None``
        :param tx: Total sent data to remote site.
        """
        self.remote_site = remote_site
        self.rx = rx
        self.stats_per_tunnel = stats_per_tunnel
        self.tx = tx
        VapiStruct.__init__(self)


RemoteTunnelStatisticsPerSite._set_binding_type(type.StructType(
    'com.vmware.nsx.model.remote_tunnel_statistics_per_site', {
        'remote_site': type.OptionalType(type.ReferenceType(__name__, 'ResourceReference')),
        'rx': type.OptionalType(type.ReferenceType(__name__, 'InterSitePortCounters')),
        'stats_per_tunnel': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'RemoteTunnelStatistics'))),
        'tx': type.OptionalType(type.ReferenceType(__name__, 'InterSitePortCounters')),
    },
    RemoteTunnelStatisticsPerSite,
    False,
    None))



class RenderConfiguration(VapiStruct):
    """
    Render configuration to be applied to the widget.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    COLOR_GREY = "GREY"
    """


    """
    COLOR_DARK_GREY = "DARK_GREY"
    """


    """
    COLOR_LIGHT_GREY = "LIGHT_GREY"
    """


    """
    COLOR_SKY_BLUE = "SKY_BLUE"
    """


    """
    COLOR_BLUE = "BLUE"
    """


    """
    COLOR_GREEN = "GREEN"
    """


    """
    COLOR_YELLOW = "YELLOW"
    """


    """
    COLOR_RED = "RED"
    """


    """
    COLOR_DARK_RED = "DARK_RED"
    """


    """



    _canonical_to_pep_names = {
                            'color': 'color',
                            'condition': 'condition',
                            'display_value': 'display_value',
                            'icons': 'icons',
                            'tooltip': 'tooltip',
                            }

    def __init__(self,
                 color=None,
                 condition=None,
                 display_value=None,
                 icons=None,
                 tooltip=None,
                ):
        """
        :type  color: :class:`str` or ``None``
        :param color: Possible values are: 
            
            * :attr:`RenderConfiguration.COLOR_GREY`
            * :attr:`RenderConfiguration.COLOR_DARK_GREY`
            * :attr:`RenderConfiguration.COLOR_LIGHT_GREY`
            * :attr:`RenderConfiguration.COLOR_SKY_BLUE`
            * :attr:`RenderConfiguration.COLOR_BLUE`
            * :attr:`RenderConfiguration.COLOR_GREEN`
            * :attr:`RenderConfiguration.COLOR_YELLOW`
            * :attr:`RenderConfiguration.COLOR_RED`
            * :attr:`RenderConfiguration.COLOR_DARK_RED`
            
            The color to use when rendering an entity. For example, set color
            as 'RED' to render a portion of donut in red.
        :type  condition: :class:`str` or ``None``
        :param condition: If the condition is met then the rendering specified for the
            condition will be applied. Examples of expression syntax are
            provided under 'example_request' section of
            'CreateWidgetConfiguration' API.
        :type  display_value: :class:`str` or ``None``
        :param display_value: If specified, overrides the field value. This can be used to
            display a meaningful value in situations where field value is not
            available or not configured.
        :type  icons: :class:`list` of :class:`Icon` or ``None``
        :param icons: Icons to be applied at dashboard for widgets and UI elements.
        :type  tooltip: :class:`list` of :class:`Tooltip` or ``None``
        :param tooltip: Multi-line text to be shown on tooltip while hovering over the UI
            element if the condition is met.
        """
        self.color = color
        self.condition = condition
        self.display_value = display_value
        self.icons = icons
        self.tooltip = tooltip
        VapiStruct.__init__(self)


RenderConfiguration._set_binding_type(type.StructType(
    'com.vmware.nsx.model.render_configuration', {
        'color': type.OptionalType(type.StringType()),
        'condition': type.OptionalType(type.StringType()),
        'display_value': type.OptionalType(type.StringType()),
        'icons': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Icon'))),
        'tooltip': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tooltip'))),
    },
    RenderConfiguration,
    False,
    None))



class ReorderMigrationRequest(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'id': 'id',
                            'is_before': 'is_before',
                            }

    def __init__(self,
                 id=None,
                 is_before=None,
                ):
        """
        :type  id: :class:`str` or ``None``
        :param id: id of the migration unit group/migration unit before/after which
            the migration unit group/migration unit is to be placed
        :type  is_before: :class:`bool` or ``None``
        :param is_before: flag indicating whether the migration unit group/migration unit is
            to be placed before or after the specified migration unit
            group/migration unit
        """
        self.id = id
        self.is_before = is_before
        VapiStruct.__init__(self)


ReorderMigrationRequest._set_binding_type(type.StructType(
    'com.vmware.nsx.model.reorder_migration_request', {
        'id': type.OptionalType(type.StringType()),
        'is_before': type.OptionalType(type.BooleanType()),
    },
    ReorderMigrationRequest,
    False,
    None))



class ReorderRequest(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'id': 'id',
                            'is_before': 'is_before',
                            }

    def __init__(self,
                 id=None,
                 is_before=None,
                ):
        """
        :type  id: :class:`str` or ``None``
        :param id: id of the upgrade unit group/upgrade unit before/after which the
            upgrade unit group/upgrade unit is to be placed
        :type  is_before: :class:`bool` or ``None``
        :param is_before: flag indicating whether the upgrade unit group/upgrade unit is to
            be placed before or after the specified upgrade unit group/upgrade
            unit
        """
        self.id = id
        self.is_before = is_before
        VapiStruct.__init__(self)


ReorderRequest._set_binding_type(type.StructType(
    'com.vmware.nsx.model.reorder_request', {
        'id': type.OptionalType(type.StringType()),
        'is_before': type.OptionalType(type.BooleanType()),
    },
    ReorderRequest,
    False,
    None))



class RepoSyncStatusReport(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATUS_NOT_STARTED = "NOT_STARTED"
    """


    """
    STATUS_IN_PROGRESS = "IN_PROGRESS"
    """


    """
    STATUS_FAILED = "FAILED"
    """


    """
    STATUS_SUCCESS = "SUCCESS"
    """


    """



    _canonical_to_pep_names = {
                            'failure_code': 'failure_code',
                            'failure_message': 'failure_message',
                            'status': 'status',
                            'status_message': 'status_message',
                            }

    def __init__(self,
                 failure_code=None,
                 failure_message=None,
                 status=None,
                 status_message=None,
                ):
        """
        :type  failure_code: :class:`long` or ``None``
        :param failure_code: In case of repo sync related failure, the code for the error will
            be stored here. format: int64
        :type  failure_message: :class:`str` or ``None``
        :param failure_message: In case if repo sync fails due to some issue, an error message will
            be stored here.
        :type  status: :class:`str` or ``None``
        :param status: Possible values are: 
            
            * :attr:`RepoSyncStatusReport.STATUS_NOT_STARTED`
            * :attr:`RepoSyncStatusReport.STATUS_IN_PROGRESS`
            * :attr:`RepoSyncStatusReport.STATUS_FAILED`
            * :attr:`RepoSyncStatusReport.STATUS_SUCCESS`
            
             Status of the repo sync operation on the single nsx-manager
        :type  status_message: :class:`str` or ``None``
        :param status_message: Describes the steps which repo sync operation is performing
            currently.
        """
        self.failure_code = failure_code
        self.failure_message = failure_message
        self.status = status
        self.status_message = status_message
        VapiStruct.__init__(self)


RepoSyncStatusReport._set_binding_type(type.StructType(
    'com.vmware.nsx.model.repo_sync_status_report', {
        'failure_code': type.OptionalType(type.IntegerType()),
        'failure_message': type.OptionalType(type.StringType()),
        'status': type.OptionalType(type.StringType()),
        'status_message': type.OptionalType(type.StringType()),
    },
    RepoSyncStatusReport,
    False,
    None))



class ReservationInfo(VapiStruct):
    """
    CPU and Memory resource configuration is defined per Edge VM form factor.
    These resources are reserved 100 percent by default with Normal VM
    importance. Resource reservation tuning provides a means to optimize
    resource utilization and workaround hard resource limits. This solution
    should be used as a temporary workaround. It is recommended to add more
    resources to the compute cluster and change the reservation back to 100
    percent for optimal performance.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'cpu_reservation': 'cpu_reservation',
                            'memory_reservation': 'memory_reservation',
                            }

    def __init__(self,
                 cpu_reservation=None,
                 memory_reservation=None,
                ):
        """
        :type  cpu_reservation: :class:`CPUReservation` or ``None``
        :param cpu_reservation: Specify a reservation if you need to guarantee that the minimum
            required amount of CPU is always available for the virtual machine.
        :type  memory_reservation: :class:`MemoryReservation` or ``None``
        :param memory_reservation: Specify a reservation if you need to guarantee that the minimum
            required amount of memory is always available for the virtual
            machine.
        """
        self.cpu_reservation = cpu_reservation
        self.memory_reservation = memory_reservation
        VapiStruct.__init__(self)


ReservationInfo._set_binding_type(type.StructType(
    'com.vmware.nsx.model.reservation_info', {
        'cpu_reservation': type.OptionalType(type.ReferenceType(__name__, 'CPUReservation')),
        'memory_reservation': type.OptionalType(type.ReferenceType(__name__, 'MemoryReservation')),
    },
    ReservationInfo,
    False,
    None))



class Resource(VapiStruct):
    """
    Base class for resources

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        VapiStruct.__init__(self)


Resource._set_binding_type(type.StructType(
    'com.vmware.nsx.model.resource', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
    },
    Resource,
    False,
    None))



class ResourceAllocation(VapiStruct):
    """
    Specify limit, shares and reservation for all kinds of traffic. Values for
    limit and reservation are expressed in percentage. And for shares, the
    value is expressed as a number between 1-100. The overall reservation among
    all traffic types should not exceed 75%. Otherwise, the API request will be
    rejected.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'limit': 'limit',
                            'reservation': 'reservation',
                            'shares': 'shares',
                            'traffic_type': 'traffic_type',
                            }

    def __init__(self,
                 limit=None,
                 reservation=None,
                 shares=None,
                 traffic_type=None,
                ):
        """
        :type  limit: :class:`float` or ``None``
        :param limit: The limit property specifies the maximum bandwidth allocation for a
            given traffic type and is expressed in percentage. The default
            value for this field is set to -1 which means the traffic is
            unbounded for the traffic type. All other negative values for this
            property is not supported and will be rejected by the API.
        :type  reservation: :class:`float` or ``None``
        :param reservation: Minimum guaranteed bandwidth percentage
        :type  shares: :class:`long` or ``None``
        :param shares: Shares format: int32
        :type  traffic_type: :class:`HostInfraTrafficType` or ``None``
        :param traffic_type: Resource allocation traffic type
        """
        self.limit = limit
        self.reservation = reservation
        self.shares = shares
        self.traffic_type = traffic_type
        VapiStruct.__init__(self)


ResourceAllocation._set_binding_type(type.StructType(
    'com.vmware.nsx.model.resource_allocation', {
        'limit': type.OptionalType(type.DoubleType()),
        'reservation': type.OptionalType(type.DoubleType()),
        'shares': type.OptionalType(type.IntegerType()),
        'traffic_type': type.OptionalType(type.ReferenceType(__name__, 'HostInfraTrafficType')),
    },
    ResourceAllocation,
    False,
    None))



class ResourceAssignment(VapiStruct):
    """
    Amount of memory and CPU allocated to the Edge VM.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'cpu_count': 'cpu_count',
                            'memory_allocation_in_mb': 'memory_allocation_in_mb',
                            }

    def __init__(self,
                 cpu_count=None,
                 memory_allocation_in_mb=None,
                ):
        """
        :type  cpu_count: :class:`long` or ``None``
        :param cpu_count: CPU count. format: int32
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  memory_allocation_in_mb: :class:`long` or ``None``
        :param memory_allocation_in_mb: Memory allocation in MB. format: int32
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.cpu_count = cpu_count
        self.memory_allocation_in_mb = memory_allocation_in_mb
        VapiStruct.__init__(self)


ResourceAssignment._set_binding_type(type.StructType(
    'com.vmware.nsx.model.resource_assignment', {
        'cpu_count': type.OptionalType(type.IntegerType()),
        'memory_allocation_in_mb': type.OptionalType(type.IntegerType()),
    },
    ResourceAssignment,
    False,
    None))



class ResourceLink(VapiStruct):
    """
    A link to a related resource

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'action': 'action',
                            'href': 'href',
                            'rel': 'rel',
                            }

    def __init__(self,
                 action=None,
                 href=None,
                 rel=None,
                ):
        """
        :type  action: :class:`str` or ``None``
        :param action: Optional action
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  href: :class:`str` or ``None``
        :param href: Link to resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  rel: :class:`str` or ``None``
        :param rel: Custom relation type (follows RFC 5988 where appropriate
            definitions exist)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.action = action
        self.href = href
        self.rel = rel
        VapiStruct.__init__(self)


ResourceLink._set_binding_type(type.StructType(
    'com.vmware.nsx.model.resource_link', {
        'action': type.OptionalType(type.StringType()),
        'href': type.OptionalType(type.StringType()),
        'rel': type.OptionalType(type.StringType()),
    },
    ResourceLink,
    False,
    None))



class ResourceReference(VapiStruct):
    """
    A weak reference to an NSX resource.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'is_valid': 'is_valid',
                            'target_display_name': 'target_display_name',
                            'target_id': 'target_id',
                            'target_type': 'target_type',
                            }

    def __init__(self,
                 is_valid=None,
                 target_display_name=None,
                 target_id=None,
                 target_type=None,
                ):
        """
        :type  is_valid: :class:`bool` or ``None``
        :param is_valid: Will be set to false if the referenced NSX resource has been
            deleted.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  target_display_name: :class:`str` or ``None``
        :param target_display_name: Display name of the NSX resource.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  target_id: :class:`str` or ``None``
        :param target_id: Identifier of the NSX resource.
        :type  target_type: :class:`str` or ``None``
        :param target_type: Type of the NSX resource.
        """
        self.is_valid = is_valid
        self.target_display_name = target_display_name
        self.target_id = target_id
        self.target_type = target_type
        VapiStruct.__init__(self)


ResourceReference._set_binding_type(type.StructType(
    'com.vmware.nsx.model.resource_reference', {
        'is_valid': type.OptionalType(type.BooleanType()),
        'target_display_name': type.OptionalType(type.StringType()),
        'target_id': type.OptionalType(type.StringType()),
        'target_type': type.OptionalType(type.StringType()),
    },
    ResourceReference,
    False,
    None))



class RestoreConfiguration(VapiStruct):
    """
    Configuration where backup files are stored for restore

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'passphrase': 'passphrase',
                            'remote_file_server': 'remote_file_server',
                            }

    def __init__(self,
                 passphrase=None,
                 remote_file_server=None,
                ):
        """
        :type  passphrase: :class:`str` or ``None``
        :param passphrase: Passphrase used to encrypt backup files.
        :type  remote_file_server: :class:`RemoteFileServer` or ``None``
        :param remote_file_server: The server from which backup files will be retrieved for restore.
        """
        self.passphrase = passphrase
        self.remote_file_server = remote_file_server
        VapiStruct.__init__(self)


RestoreConfiguration._set_binding_type(type.StructType(
    'com.vmware.nsx.model.restore_configuration', {
        'passphrase': type.OptionalType(type.StringType()),
        'remote_file_server': type.OptionalType(type.ReferenceType(__name__, 'RemoteFileServer')),
    },
    RestoreConfiguration,
    False,
    None))



class RestoreStep(VapiStruct):
    """
    Restore step info

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'description': 'description',
                            'status': 'status',
                            'step_number': 'step_number',
                            'value': 'value',
                            }

    def __init__(self,
                 description=None,
                 status=None,
                 step_number=None,
                 value=None,
                ):
        """
        :type  description: :class:`str` or ``None``
        :param description: Restore step description
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  status: :class:`PerStepRestoreStatus` or ``None``
        :param status: 
        :type  step_number: :class:`long` or ``None``
        :param step_number: Restore step number format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  value: :class:`str` or ``None``
        :param value: Restore step value
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.description = description
        self.status = status
        self.step_number = step_number
        self.value = value
        VapiStruct.__init__(self)


RestoreStep._set_binding_type(type.StructType(
    'com.vmware.nsx.model.restore_step', {
        'description': type.OptionalType(type.StringType()),
        'status': type.OptionalType(type.ReferenceType(__name__, 'PerStepRestoreStatus')),
        'step_number': type.OptionalType(type.IntegerType()),
        'value': type.OptionalType(type.StringType()),
    },
    RestoreStep,
    False,
    None))



class RevisionedResource(VapiStruct):
    """
    A base class for types that track revisions

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        VapiStruct.__init__(self)


RevisionedResource._set_binding_type(type.StructType(
    'com.vmware.nsx.model.revisioned_resource', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
    },
    RevisionedResource,
    False,
    None))



class Role(VapiStruct):
    """
    Role

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'role': 'role',
                            'role_display_name': 'role_display_name',
                            }

    def __init__(self,
                 role=None,
                 role_display_name=None,
                ):
        """
        :type  role: :class:`str` or ``None``
        :param role: Short identifier for the role. Must be all lower case with no
            spaces.
        :type  role_display_name: :class:`str` or ``None``
        :param role_display_name: A short, human-friendly display name of the role.
        """
        self.role = role
        self.role_display_name = role_display_name
        VapiStruct.__init__(self)


Role._set_binding_type(type.StructType(
    'com.vmware.nsx.model.role', {
        'role': type.OptionalType(type.StringType()),
        'role_display_name': type.OptionalType(type.StringType()),
    },
    Role,
    False,
    None))



class RoleBinding(VapiStruct):
    """
    User/Group's role binding

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    IDENTITY_SOURCE_TYPE_VIDM = "VIDM"
    """


    """
    IDENTITY_SOURCE_TYPE_LDAP = "LDAP"
    """


    """
    STALE_TRUE = "TRUE"
    """


    """
    STALE_FALSE = "FALSE"
    """


    """
    STALE_UNKNOWN = "UNKNOWN"
    """


    """
    TYPE_REMOTE_USER = "remote_user"
    """


    """
    TYPE_REMOTE_GROUP = "remote_group"
    """


    """
    TYPE_LOCAL_USER = "local_user"
    """


    """
    TYPE_PRINCIPAL_IDENTITY = "principal_identity"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'identity_source_id': 'identity_source_id',
                            'identity_source_type': 'identity_source_type',
                            'name': 'name',
                            'roles': 'roles',
                            'stale': 'stale',
                            'type': 'type',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 identity_source_id=None,
                 identity_source_type=None,
                 name=None,
                 roles=None,
                 stale=None,
                 type=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  identity_source_id: :class:`str` or ``None``
        :param identity_source_id: The ID of the external identity source that holds the referenced
            external entity. Currently, only external LDAP servers are allowed.
        :type  identity_source_type: :class:`str` or ``None``
        :param identity_source_type: Possible values are: 
            
            * :attr:`RoleBinding.IDENTITY_SOURCE_TYPE_VIDM`
            * :attr:`RoleBinding.IDENTITY_SOURCE_TYPE_LDAP`
            
             Identity source type
        :type  name: :class:`str` or ``None``
        :param name: User/Group's name
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  roles: :class:`list` of :class:`Role` or ``None``
        :param roles: Roles
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  stale: :class:`str` or ``None``
        :param stale: Possible values are: 
            
            * :attr:`RoleBinding.STALE_TRUE`
            * :attr:`RoleBinding.STALE_FALSE`
            * :attr:`RoleBinding.STALE_UNKNOWN`
            
            Property 'stale' can be considered to have these values - absent -
            This type of rolebinding does not support stale property TRUE -
            Rolebinding is stale in vIDM meaning the user is no longer present
            in vIDM FALSE - Rolebinding is available in vIDM UNKNOWN -
            Rolebinding's state of staleness in unknown Once rolebindings
            become stale, they can be deleted using the API POST
            /aaa/role-bindings?action=delete_stale_bindings
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  type: :class:`str` or ``None``
        :param type: Possible values are: 
            
            * :attr:`RoleBinding.TYPE_REMOTE_USER`
            * :attr:`RoleBinding.TYPE_REMOTE_GROUP`
            * :attr:`RoleBinding.TYPE_LOCAL_USER`
            * :attr:`RoleBinding.TYPE_PRINCIPAL_IDENTITY`
            
             Type
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.identity_source_id = identity_source_id
        self.identity_source_type = identity_source_type
        self.name = name
        self.roles = roles
        self.stale = stale
        self.type = type
        VapiStruct.__init__(self)


RoleBinding._set_binding_type(type.StructType(
    'com.vmware.nsx.model.role_binding', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'identity_source_id': type.OptionalType(type.StringType()),
        'identity_source_type': type.OptionalType(type.StringType()),
        'name': type.OptionalType(type.StringType()),
        'roles': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Role'))),
        'stale': type.OptionalType(type.StringType()),
        'type': type.OptionalType(type.StringType()),
    },
    RoleBinding,
    False,
    None))



class RoleBindingListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`RoleBinding` or ``None``
        :param results: List results
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


RoleBindingListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.role_binding_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'RoleBinding'))),
    },
    RoleBindingListResult,
    False,
    None))



class RoleListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`Role` or ``None``
        :param results: List results
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


RoleListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.role_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Role'))),
    },
    RoleListResult,
    False,
    None))



class RoleWithFeatures(VapiStruct):
    """
    Role

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'features': 'features',
                            'role': 'role',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 features=None,
                 role=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  features: :class:`list` of :class:`FeaturePermission` or ``None``
        :param features: Features
        :type  role: :class:`str` or ``None``
        :param role: Short identifier for the role. Must be all lower case with no
            spaces.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.features = features
        self.role = role
        VapiStruct.__init__(self)


RoleWithFeatures._set_binding_type(type.StructType(
    'com.vmware.nsx.model.role_with_features', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'features': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'FeaturePermission'))),
        'role': type.OptionalType(type.StringType()),
    },
    RoleWithFeatures,
    False,
    None))



class RoleWithFeaturesListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`RoleWithFeatures` or ``None``
        :param results: List results
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


RoleWithFeaturesListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.role_with_features_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'RoleWithFeatures'))),
    },
    RoleWithFeaturesListResult,
    False,
    None))



class RouteBasedIPSecVPNSession(VapiStruct):
    """
    A Route Based VPN is more flexible, more powerful and recommended over
    policy based VPN. IP Tunnel port is created and all traffic routed via
    tunnel port is protected. Routes can be configured statically or can be
    learned through BGP. A route based VPN is must for establishing redundant
    VPN session to remote site.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "RouteBasedIPSecVPNSession"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'tunnel_ports': 'tunnel_ports',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'enabled': 'enabled',
                            'ipsec_vpn_service_id': 'ipsec_vpn_service_id',
                            'local_endpoint_id': 'local_endpoint_id',
                            'peer_endpoint_id': 'peer_endpoint_id',
                            'tcp_mss_clamping': 'tcp_mss_clamping',
                            }

    def __init__(self,
                 tunnel_ports=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='RouteBasedIPSecVPNSession',
                 tags=None,
                 enabled=None,
                 ipsec_vpn_service_id=None,
                 local_endpoint_id=None,
                 peer_endpoint_id=None,
                 tcp_mss_clamping=None,
                ):
        """
        :type  tunnel_ports: :class:`list` of :class:`TunnelPortConfig` or ``None``
        :param tunnel_ports: IP Tunnel ports.
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`IPSecVPNSession.RESOURCE_TYPE_POLICYBASEDIPSECVPNSESSION`
            * :attr:`IPSecVPNSession.RESOURCE_TYPE_ROUTEBASEDIPSECVPNSESSION`
            
            A Policy Based VPN requires to define protect rules that match
            local and peer subnets. IPSec security associations is negotiated
            for each pair of local and peer subnet. A Route Based VPN is more
            flexible, more powerful and recommended over policy based VPN. IP
            Tunnel port is created and all traffic routed via tunnel port is
            protected. Routes can be configured statically or can be learned
            through BGP. A route based VPN is must for establishing redundant
            VPN session to remote site.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  enabled: :class:`bool` or ``None``
        :param enabled: Enable/Disable IPSec VPN session.
        :type  ipsec_vpn_service_id: :class:`str` or ``None``
        :param ipsec_vpn_service_id: Identifier of VPN Service linked with local endpoint.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  local_endpoint_id: :class:`str` or ``None``
        :param local_endpoint_id: Local endpoint identifier.
        :type  peer_endpoint_id: :class:`str` or ``None``
        :param peer_endpoint_id: Peer endpoint identifier.
        :type  tcp_mss_clamping: :class:`TcpMssClamping` or ``None``
        :param tcp_mss_clamping: 
        """
        self.tunnel_ports = tunnel_ports
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        self.enabled = enabled
        self.ipsec_vpn_service_id = ipsec_vpn_service_id
        self.local_endpoint_id = local_endpoint_id
        self.peer_endpoint_id = peer_endpoint_id
        self.tcp_mss_clamping = tcp_mss_clamping
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

RouteBasedIPSecVPNSession._set_binding_type(type.StructType(
    'com.vmware.nsx.model.route_based_IP_sec_VPN_session', {
        'tunnel_ports': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'TunnelPortConfig'))),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'enabled': type.OptionalType(type.BooleanType()),
        'ipsec_vpn_service_id': type.OptionalType(type.StringType()),
        'local_endpoint_id': type.OptionalType(type.StringType()),
        'peer_endpoint_id': type.OptionalType(type.StringType()),
        'tcp_mss_clamping': type.OptionalType(type.ReferenceType(__name__, 'TcpMssClamping')),
    },
    RouteBasedIPSecVPNSession,
    False,
    None))



class RouteDetails(VapiStruct):
    """
    BGP route details.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'as_path': 'as_path',
                            'local_pref': 'local_pref',
                            'med': 'med',
                            'network': 'network',
                            'next_hop': 'next_hop',
                            'weight': 'weight',
                            }

    def __init__(self,
                 as_path=None,
                 local_pref=None,
                 med=None,
                 network=None,
                 next_hop=None,
                 weight=None,
                ):
        """
        :type  as_path: :class:`str` or ``None``
        :param as_path: BGP AS path attribute.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  local_pref: :class:`long` or ``None``
        :param local_pref: BGP Local Preference attribute. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  med: :class:`long` or ``None``
        :param med: BGP Multi Exit Discriminator attribute. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  network: :class:`str` or ``None``
        :param network: CIDR network address. format: ip-cidr-block
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  next_hop: :class:`str` or ``None``
        :param next_hop: Next hop IP address. format: ip
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  weight: :class:`long` or ``None``
        :param weight: BGP Weight attribute. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.as_path = as_path
        self.local_pref = local_pref
        self.med = med
        self.network = network
        self.next_hop = next_hop
        self.weight = weight
        VapiStruct.__init__(self)


RouteDetails._set_binding_type(type.StructType(
    'com.vmware.nsx.model.route_details', {
        'as_path': type.OptionalType(type.StringType()),
        'local_pref': type.OptionalType(type.IntegerType()),
        'med': type.OptionalType(type.IntegerType()),
        'network': type.OptionalType(type.StringType()),
        'next_hop': type.OptionalType(type.StringType()),
        'weight': type.OptionalType(type.IntegerType()),
    },
    RouteDetails,
    False,
    None))



class RouteMap(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'logical_router_id': 'logical_router_id',
                            'sequences': 'sequences',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 logical_router_id=None,
                 sequences=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  logical_router_id: :class:`str` or ``None``
        :param logical_router_id: Logical router id
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sequences: :class:`list` of :class:`RouteMapSequence` or ``None``
        :param sequences: Ordered list of routeMap sequences
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.logical_router_id = logical_router_id
        self.sequences = sequences
        VapiStruct.__init__(self)


RouteMap._set_binding_type(type.StructType(
    'com.vmware.nsx.model.route_map', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'logical_router_id': type.OptionalType(type.StringType()),
        'sequences': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'RouteMapSequence'))),
    },
    RouteMap,
    False,
    None))



class RouteMapListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`RouteMap` or ``None``
        :param results: Paginated list of RouteMaps
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


RouteMapListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.route_map_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'RouteMap'))),
    },
    RouteMapListResult,
    False,
    None))



class RouteMapSequence(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    ACTION_PERMIT = "PERMIT"
    """


    """
    ACTION_DENY = "DENY"
    """


    """



    _canonical_to_pep_names = {
                            'action': 'action',
                            'match_criteria': 'match_criteria',
                            'set_criteria': 'set_criteria',
                            }

    def __init__(self,
                 action=None,
                 match_criteria=None,
                 set_criteria=None,
                ):
        """
        :type  action: :class:`str` or ``None``
        :param action: Possible values are: 
            
            * :attr:`RouteMapSequence.ACTION_PERMIT`
            * :attr:`RouteMapSequence.ACTION_DENY`
            
             Action for the Sequence
        :type  match_criteria: :class:`RouteMapSequenceMatch` or ``None``
        :param match_criteria: Match Criteria for the RouteMap Sequence
        :type  set_criteria: :class:`RouteMapSequenceSet` or ``None``
        :param set_criteria: Set Criteria for the RouteMap Sequence
        """
        self.action = action
        self.match_criteria = match_criteria
        self.set_criteria = set_criteria
        VapiStruct.__init__(self)


RouteMapSequence._set_binding_type(type.StructType(
    'com.vmware.nsx.model.route_map_sequence', {
        'action': type.OptionalType(type.StringType()),
        'match_criteria': type.OptionalType(type.ReferenceType(__name__, 'RouteMapSequenceMatch')),
        'set_criteria': type.OptionalType(type.ReferenceType(__name__, 'RouteMapSequenceSet')),
    },
    RouteMapSequence,
    False,
    None))



class RouteMapSequenceMatch(VapiStruct):
    """
    Match sequence in route map which is used for matching routes. IP prefix
    lists and match community expression are mutually exclusive fields, one of
    them must be provided.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'ip_prefix_lists': 'ip_prefix_lists',
                            'match_community_expression': 'match_community_expression',
                            }

    def __init__(self,
                 ip_prefix_lists=None,
                 match_community_expression=None,
                ):
        """
        :type  ip_prefix_lists: :class:`list` of :class:`str` or ``None``
        :param ip_prefix_lists: IPPrefixList Identifiers for RouteMap Sequence Match Criteria
        :type  match_community_expression: :class:`CommunityMatchExpression` or ``None``
        :param match_community_expression: It supports conjunction operator (AND) and five operators within
            singular community match expression (MATCH_ANY, MATCH_ALL,
            MATCH_EXACT, MATCH_NONE, MATCH_REGEX).
        """
        self.ip_prefix_lists = ip_prefix_lists
        self.match_community_expression = match_community_expression
        VapiStruct.__init__(self)


RouteMapSequenceMatch._set_binding_type(type.StructType(
    'com.vmware.nsx.model.route_map_sequence_match', {
        'ip_prefix_lists': type.OptionalType(type.ListType(type.StringType())),
        'match_community_expression': type.OptionalType(type.ReferenceType(__name__, 'CommunityMatchExpression')),
    },
    RouteMapSequenceMatch,
    False,
    None))



class RouteMapSequenceSet(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'as_path_prepend': 'as_path_prepend',
                            'community': 'community',
                            'large_community': 'large_community',
                            'local_preference': 'local_preference',
                            'multi_exit_discriminator': 'multi_exit_discriminator',
                            'prefer_global_v6_next_hop': 'prefer_global_v6_next_hop',
                            'weight': 'weight',
                            }

    def __init__(self,
                 as_path_prepend=None,
                 community=None,
                 large_community=None,
                 local_preference=None,
                 multi_exit_discriminator=None,
                 prefer_global_v6_next_hop=None,
                 weight=None,
                ):
        """
        :type  as_path_prepend: :class:`str` or ``None``
        :param as_path_prepend: As Path Prepending to influence path selection
        :type  community: :class:`str` or ``None``
        :param community: Set normal BGP community either well-known community name or
            community value in aa:nn(2byte:2byte) format.
        :type  large_community: :class:`str` or ``None``
        :param large_community: Set large BGP community, community value shoud be in aa:bb:nn
            format where aa, bb, nn are unsigned integers with range
            [1-4294967295].
        :type  local_preference: :class:`long` or ``None``
        :param local_preference: Local preference indicates the degree of preference for one BGP
            route over other BGP routes. The path/route with highest local
            preference value is preferred/selected. If local preference value
            is not specified then it will be considered as 100 by default.
            format: int64
        :type  multi_exit_discriminator: :class:`long` or ``None``
        :param multi_exit_discriminator: Multi Exit Discriminator (MED) format: int64
        :type  prefer_global_v6_next_hop: :class:`bool` or ``None``
        :param prefer_global_v6_next_hop: For incoming and import route_maps on receiving both v6 global and
            v6 link-local address for the route, prefer to use the global
            address as the next hop. By default, it prefers the link-local next
            hop.
        :type  weight: :class:`long` or ``None``
        :param weight: Weight used to select certain path format: int32
        """
        self.as_path_prepend = as_path_prepend
        self.community = community
        self.large_community = large_community
        self.local_preference = local_preference
        self.multi_exit_discriminator = multi_exit_discriminator
        self.prefer_global_v6_next_hop = prefer_global_v6_next_hop
        self.weight = weight
        VapiStruct.__init__(self)


RouteMapSequenceSet._set_binding_type(type.StructType(
    'com.vmware.nsx.model.route_map_sequence_set', {
        'as_path_prepend': type.OptionalType(type.StringType()),
        'community': type.OptionalType(type.StringType()),
        'large_community': type.OptionalType(type.StringType()),
        'local_preference': type.OptionalType(type.IntegerType()),
        'multi_exit_discriminator': type.OptionalType(type.IntegerType()),
        'prefer_global_v6_next_hop': type.OptionalType(type.BooleanType()),
        'weight': type.OptionalType(type.IntegerType()),
    },
    RouteMapSequenceSet,
    False,
    None))



class RoutesPerTransportNode(VapiStruct):
    """
    BGP routes per transport node.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'routes': 'routes',
                            'source_address': 'source_address',
                            'transport_node_id': 'transport_node_id',
                            }

    def __init__(self,
                 routes=None,
                 source_address=None,
                 transport_node_id=None,
                ):
        """
        :type  routes: :class:`list` of :class:`RouteDetails` or ``None``
        :param routes: Array of BGP neighbor route details for this transport node.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  source_address: :class:`str` or ``None``
        :param source_address: BGP neighbor source address. format: ip
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  transport_node_id: :class:`str` or ``None``
        :param transport_node_id: Transport node id
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.routes = routes
        self.source_address = source_address
        self.transport_node_id = transport_node_id
        VapiStruct.__init__(self)


RoutesPerTransportNode._set_binding_type(type.StructType(
    'com.vmware.nsx.model.routes_per_transport_node', {
        'routes': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'RouteDetails'))),
        'source_address': type.OptionalType(type.StringType()),
        'transport_node_id': type.OptionalType(type.StringType()),
    },
    RoutesPerTransportNode,
    False,
    None))



class RoutingConfig(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'forwarding_up_timer': 'forwarding_up_timer',
                            'logical_router_id': 'logical_router_id',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 forwarding_up_timer=None,
                 logical_router_id=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  forwarding_up_timer: :class:`long` or ``None``
        :param forwarding_up_timer: Defines the extra time the router must wait before sending the UP
            notification after the first BGP session is established. Default
            means forward immediately. For TIER0/TIER1 logical router, default
            is 0. VRF logical router will set it same as parent logical router.
            format: int64
        :type  logical_router_id: :class:`str` or ``None``
        :param logical_router_id: Logical router id
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.forwarding_up_timer = forwarding_up_timer
        self.logical_router_id = logical_router_id
        VapiStruct.__init__(self)


RoutingConfig._set_binding_type(type.StructType(
    'com.vmware.nsx.model.routing_config', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'forwarding_up_timer': type.OptionalType(type.IntegerType()),
        'logical_router_id': type.OptionalType(type.StringType()),
    },
    RoutingConfig,
    False,
    None))



class RoutingGlobalConfig(VapiStruct):
    """
    NSX global configs for Routing

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "RoutingGlobalConfig"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    L3FORWARDING_MODE_ONLY = "IPV4_ONLY"
    """


    """
    L3FORWARDING_MODE_AND_IPV6 = "IPV4_AND_IPV6"
    """


    """



    _canonical_to_pep_names = {
                            'l3_forwarding_mode': 'l3_forwarding_mode',
                            'logical_uplink_mtu': 'logical_uplink_mtu',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            }

    def __init__(self,
                 l3_forwarding_mode=None,
                 logical_uplink_mtu=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='RoutingGlobalConfig',
                 tags=None,
                ):
        """
        :type  l3_forwarding_mode: :class:`str` or ``None``
        :param l3_forwarding_mode: Possible values are: 
            
            * :attr:`RoutingGlobalConfig.L3FORWARDING_MODE_ONLY`
            * :attr:`RoutingGlobalConfig.L3FORWARDING_MODE_AND_IPV6`
            
            This setting does not restrict configuration as per other modes.
            But the forwarding will only work as per the mode set here.
        :type  logical_uplink_mtu: :class:`long` or ``None``
        :param logical_uplink_mtu: This is the global default MTU for all the logical uplinks in a NSX
            domain. Currently logical uplink MTU can only be set globally and
            applies to the entire NSX domain. There is no option to override
            this value at transport zone level or transport node level. If this
            value is not set, the default value of 1500 will be used. format:
            int32
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`GlobalConfigs.RESOURCE_TYPE_SWITCHINGGLOBALCONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_ROUTINGGLOBALCONFIG`
            *
              :attr:`GlobalConfigs.RESOURCE_TYPE_OPERATIONCOLLECTORGLOBALCONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_FIREWALLGLOBALCONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_ESXGLOBALOPAQUECONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_SECURITYGLOBALCONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_FIPSGLOBALCONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_FEDERATIONGLOBALCONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_IDSGLOBALCONFIG`
            
             Valid Global configuration types
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        """
        self.l3_forwarding_mode = l3_forwarding_mode
        self.logical_uplink_mtu = logical_uplink_mtu
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

RoutingGlobalConfig._set_binding_type(type.StructType(
    'com.vmware.nsx.model.routing_global_config', {
        'l3_forwarding_mode': type.OptionalType(type.StringType()),
        'logical_uplink_mtu': type.OptionalType(type.IntegerType()),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
    },
    RoutingGlobalConfig,
    False,
    None))



class RoutingPolicy(VapiStruct):
    """
    Routing policy details.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    ROUTING_POLICY_TYPE_ROUTING = "PROXIMITY_ROUTING"
    """


    """



    _canonical_to_pep_names = {
                            'next_hop_prefix_lists_mappings': 'next_hop_prefix_lists_mappings',
                            'routing_policy_type': 'routing_policy_type',
                            }

    def __init__(self,
                 next_hop_prefix_lists_mappings=None,
                 routing_policy_type=None,
                ):
        """
        :type  next_hop_prefix_lists_mappings: :class:`list` of :class:`NextHopPrefixListsMapping` or ``None``
        :param next_hop_prefix_lists_mappings: Array of next hop to prefix lists mapping.
        :type  routing_policy_type: :class:`str` or ``None``
        :param routing_policy_type: Possible values are: 
            
            * :attr:`RoutingPolicy.ROUTING_POLICY_TYPE_ROUTING`
            
             Routing policy type.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.next_hop_prefix_lists_mappings = next_hop_prefix_lists_mappings
        self.routing_policy_type = routing_policy_type
        VapiStruct.__init__(self)


RoutingPolicy._set_binding_type(type.StructType(
    'com.vmware.nsx.model.routing_policy', {
        'next_hop_prefix_lists_mappings': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NextHopPrefixListsMapping'))),
        'routing_policy_type': type.OptionalType(type.StringType()),
    },
    RoutingPolicy,
    False,
    None))



class RowListField(VapiStruct):
    """
    Root of the api result set for forming rows.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'alias': 'alias',
                            'path': 'path',
                            }

    def __init__(self,
                 alias=None,
                 path=None,
                ):
        """
        :type  alias: :class:`str` or ``None``
        :param alias: 
        :type  path: :class:`str` or ``None``
        :param path: JSON path to the root of the api result set for forming rows.
        """
        self.alias = alias
        self.path = path
        VapiStruct.__init__(self)


RowListField._set_binding_type(type.StructType(
    'com.vmware.nsx.model.row_list_field', {
        'alias': type.OptionalType(type.StringType()),
        'path': type.OptionalType(type.StringType()),
    },
    RowListField,
    False,
    None))



class RuleState(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATE_PENDING = "pending"
    """


    """
    STATE_IN_PROGRESS = "in_progress"
    """


    """
    STATE_SUCCESS = "success"
    """


    """
    STATE_FAILED = "failed"
    """


    """
    STATE_PARTIAL_SUCCESS = "partial_success"
    """


    """
    STATE_ORPHANED = "orphaned"
    """


    """
    STATE_UNKNOWN = "unknown"
    """


    """
    STATE_ERROR = "error"
    """


    """
    STATE_IN_SYNC = "in_sync"
    """


    """
    STATE_NOT_AVAILABLE = "NOT_AVAILABLE"
    """


    """
    STATE_VM_DEPLOYMENT_QUEUED = "VM_DEPLOYMENT_QUEUED"
    """


    """
    STATE_VM_DEPLOYMENT_IN_PROGRESS = "VM_DEPLOYMENT_IN_PROGRESS"
    """


    """
    STATE_VM_DEPLOYMENT_FAILED = "VM_DEPLOYMENT_FAILED"
    """


    """
    STATE_VM_POWER_ON_IN_PROGRESS = "VM_POWER_ON_IN_PROGRESS"
    """


    """
    STATE_VM_POWER_ON_FAILED = "VM_POWER_ON_FAILED"
    """


    """
    STATE_REGISTRATION_PENDING = "REGISTRATION_PENDING"
    """


    """
    STATE_NODE_NOT_READY = "NODE_NOT_READY"
    """


    """
    STATE_NODE_READY = "NODE_READY"
    """


    """
    STATE_VM_POWER_OFF_IN_PROGRESS = "VM_POWER_OFF_IN_PROGRESS"
    """


    """
    STATE_VM_POWER_OFF_FAILED = "VM_POWER_OFF_FAILED"
    """


    """
    STATE_VM_UNDEPLOY_IN_PROGRESS = "VM_UNDEPLOY_IN_PROGRESS"
    """


    """
    STATE_VM_UNDEPLOY_FAILED = "VM_UNDEPLOY_FAILED"
    """


    """
    STATE_VM_UNDEPLOY_SUCCESSFUL = "VM_UNDEPLOY_SUCCESSFUL"
    """


    """
    STATE_EDGE_CONFIG_ERROR = "EDGE_CONFIG_ERROR"
    """


    """
    STATE_VM_DEPLOYMENT_RESTARTED = "VM_DEPLOYMENT_RESTARTED"
    """


    """
    STATE_REGISTRATION_FAILED = "REGISTRATION_FAILED"
    """


    """
    STATE_TRANSPORT_NODE_SYNC_PENDING = "TRANSPORT_NODE_SYNC_PENDING"
    """


    """
    STATE_TRANSPORT_NODE_CONFIGURATION_MISSING = "TRANSPORT_NODE_CONFIGURATION_MISSING"
    """


    """
    STATE_EDGE_HARDWARE_NOT_SUPPORTED = "EDGE_HARDWARE_NOT_SUPPORTED"
    """


    """
    STATE_MULTIPLE_OVERLAY_TZS_NOT_SUPPORTED = "MULTIPLE_OVERLAY_TZS_NOT_SUPPORTED"
    """


    """
    STATE_TN_OVERLAY_TZ_IN_USE_BY_EDGE_CLUSTER = "TN_OVERLAY_TZ_IN_USE_BY_EDGE_CLUSTER"
    """


    """
    STATE_TZ_ENDPOINTS_NOT_SPECIFIED = "TZ_ENDPOINTS_NOT_SPECIFIED"
    """


    """
    STATE_NO_PNIC_PREPARED_IN_EDGE = "NO_PNIC_PREPARED_IN_EDGE"
    """


    """
    STATE_APPLIANCE_INTERNAL_ERROR = "APPLIANCE_INTERNAL_ERROR"
    """


    """
    STATE_VTEP_DHCP_NOT_SUPPORTED = "VTEP_DHCP_NOT_SUPPORTED"
    """


    """
    STATE_UNSUPPORTED_HOST_SWITCH_PROFILE = "UNSUPPORTED_HOST_SWITCH_PROFILE"
    """


    """
    STATE_UPLINK_HOST_SWITCH_PROFILE_NOT_SPECIFIED = "UPLINK_HOST_SWITCH_PROFILE_NOT_SPECIFIED"
    """


    """
    STATE_HOSTSWITCH_PROFILE_NOT_FOUND = "HOSTSWITCH_PROFILE_NOT_FOUND"
    """


    """
    STATE_LLDP_SEND_ENABLED_NOT_SUPPORTED = "LLDP_SEND_ENABLED_NOT_SUPPORTED"
    """


    """
    STATE_UNSUPPORTED_NAMED_TEAMING_POLICY = "UNSUPPORTED_NAMED_TEAMING_POLICY"
    """


    """
    STATE_LBSRCID_NOT_SUPPORTED_FOR_EDGE_VM = "LBSRCID_NOT_SUPPORTED_FOR_EDGE_VM"
    """


    """
    STATE_LACP_NOT_SUPPORTED_FOR_EDGE_VM = "LACP_NOT_SUPPORTED_FOR_EDGE_VM"
    """


    """
    STATE_STANDBY_UPLINKS_NOT_SUPPORTED_FOR_EDGE_VM = "STANDBY_UPLINKS_NOT_SUPPORTED_FOR_EDGE_VM"
    """


    """
    STATE_MULTIPLE_ACTIVE_UPLINKS_NOT_SUPPORTED_FOR_EDGE = "MULTIPLE_ACTIVE_UPLINKS_NOT_SUPPORTED_FOR_EDGE"
    """


    """
    STATE_UNSUPPORTED_LACP_LB_ALGO_FOR_NODE = "UNSUPPORTED_LACP_LB_ALGO_FOR_NODE"
    """


    """
    STATE_EDGE_NODE_VERSION_NOT_SUPPORTED = "EDGE_NODE_VERSION_NOT_SUPPORTED"
    """


    """
    STATE_NO_PNIC_SPECIFIED_IN_TN = "NO_PNIC_SPECIFIED_IN_TN"
    """


    """
    STATE_INVALID_PNIC_DEVICE_NAME = "INVALID_PNIC_DEVICE_NAME"
    """


    """
    STATE_TRANSPORT_NODE_READY = "TRANSPORT_NODE_READY"
    """


    """
    STATE_VM_NETWORK_EDIT_PENDING = "VM_NETWORK_EDIT_PENDING"
    """


    """
    STATE_UNSUPPORTED_DEFAULT_TEAMING_POLICY = "UNSUPPORTED_DEFAULT_TEAMING_POLICY"
    """


    """
    STATE_MPA_DISCONNECTED = "MPA_DISCONNECTED"
    """


    """
    STATE_VM_RENAME_PENDING = "VM_RENAME_PENDING"
    """


    """
    STATE_VM_CONFIG_EDIT_PENDING = "VM_CONFIG_EDIT_PENDING"
    """


    """
    STATE_VM_NETWORK_EDIT_FAILED = "VM_NETWORK_EDIT_FAILED"
    """


    """
    STATE_VM_RENAME_FAILED = "VM_RENAME_FAILED"
    """


    """
    STATE_VM_CONFIG_EDIT_FAILED = "VM_CONFIG_EDIT_FAILED"
    """


    """
    STATE_VM_CONFIG_DISCREPANCY = "VM_CONFIG_DISCREPANCY"
    """


    """
    STATE_VM_NODE_REFRESH_FAILED = "VM_NODE_REFRESH_FAILED"
    """


    """
    STATE_VM_PLACEMENT_REFRESH_FAILED = "VM_PLACEMENT_REFRESH_FAILED"
    """


    """
    STATE_REGISTRATION_TIMEDOUT = "REGISTRATION_TIMEDOUT"
    """


    """



    _canonical_to_pep_names = {
                            'details': 'details',
                            'failure_code': 'failure_code',
                            'failure_message': 'failure_message',
                            'state': 'state',
                            'revision_desired': 'revision_desired',
                            'pending_change_list': 'pending_change_list',
                            }

    def __init__(self,
                 details=None,
                 failure_code=None,
                 failure_message=None,
                 state=None,
                 revision_desired=None,
                 pending_change_list=None,
                ):
        """
        :type  details: :class:`list` of :class:`ConfigurationStateElement` or ``None``
        :param details: Array of configuration state of various sub systems
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  failure_code: :class:`long` or ``None``
        :param failure_code: Error code format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  failure_message: :class:`str` or ``None``
        :param failure_message: Error message in case of failure
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  state: :class:`str` or ``None``
        :param state: Possible values are: 
            
            * :attr:`RuleState.STATE_PENDING`
            * :attr:`RuleState.STATE_IN_PROGRESS`
            * :attr:`RuleState.STATE_SUCCESS`
            * :attr:`RuleState.STATE_FAILED`
            * :attr:`RuleState.STATE_PARTIAL_SUCCESS`
            * :attr:`RuleState.STATE_ORPHANED`
            * :attr:`RuleState.STATE_UNKNOWN`
            * :attr:`RuleState.STATE_ERROR`
            * :attr:`RuleState.STATE_IN_SYNC`
            * :attr:`RuleState.STATE_NOT_AVAILABLE`
            * :attr:`RuleState.STATE_VM_DEPLOYMENT_QUEUED`
            * :attr:`RuleState.STATE_VM_DEPLOYMENT_IN_PROGRESS`
            * :attr:`RuleState.STATE_VM_DEPLOYMENT_FAILED`
            * :attr:`RuleState.STATE_VM_POWER_ON_IN_PROGRESS`
            * :attr:`RuleState.STATE_VM_POWER_ON_FAILED`
            * :attr:`RuleState.STATE_REGISTRATION_PENDING`
            * :attr:`RuleState.STATE_NODE_NOT_READY`
            * :attr:`RuleState.STATE_NODE_READY`
            * :attr:`RuleState.STATE_VM_POWER_OFF_IN_PROGRESS`
            * :attr:`RuleState.STATE_VM_POWER_OFF_FAILED`
            * :attr:`RuleState.STATE_VM_UNDEPLOY_IN_PROGRESS`
            * :attr:`RuleState.STATE_VM_UNDEPLOY_FAILED`
            * :attr:`RuleState.STATE_VM_UNDEPLOY_SUCCESSFUL`
            * :attr:`RuleState.STATE_EDGE_CONFIG_ERROR`
            * :attr:`RuleState.STATE_VM_DEPLOYMENT_RESTARTED`
            * :attr:`RuleState.STATE_REGISTRATION_FAILED`
            * :attr:`RuleState.STATE_TRANSPORT_NODE_SYNC_PENDING`
            * :attr:`RuleState.STATE_TRANSPORT_NODE_CONFIGURATION_MISSING`
            * :attr:`RuleState.STATE_EDGE_HARDWARE_NOT_SUPPORTED`
            * :attr:`RuleState.STATE_MULTIPLE_OVERLAY_TZS_NOT_SUPPORTED`
            * :attr:`RuleState.STATE_TN_OVERLAY_TZ_IN_USE_BY_EDGE_CLUSTER`
            * :attr:`RuleState.STATE_TZ_ENDPOINTS_NOT_SPECIFIED`
            * :attr:`RuleState.STATE_NO_PNIC_PREPARED_IN_EDGE`
            * :attr:`RuleState.STATE_APPLIANCE_INTERNAL_ERROR`
            * :attr:`RuleState.STATE_VTEP_DHCP_NOT_SUPPORTED`
            * :attr:`RuleState.STATE_UNSUPPORTED_HOST_SWITCH_PROFILE`
            * :attr:`RuleState.STATE_UPLINK_HOST_SWITCH_PROFILE_NOT_SPECIFIED`
            * :attr:`RuleState.STATE_HOSTSWITCH_PROFILE_NOT_FOUND`
            * :attr:`RuleState.STATE_LLDP_SEND_ENABLED_NOT_SUPPORTED`
            * :attr:`RuleState.STATE_UNSUPPORTED_NAMED_TEAMING_POLICY`
            * :attr:`RuleState.STATE_LBSRCID_NOT_SUPPORTED_FOR_EDGE_VM`
            * :attr:`RuleState.STATE_LACP_NOT_SUPPORTED_FOR_EDGE_VM`
            * :attr:`RuleState.STATE_STANDBY_UPLINKS_NOT_SUPPORTED_FOR_EDGE_VM`
            *
              :attr:`RuleState.STATE_MULTIPLE_ACTIVE_UPLINKS_NOT_SUPPORTED_FOR_EDGE`
            * :attr:`RuleState.STATE_UNSUPPORTED_LACP_LB_ALGO_FOR_NODE`
            * :attr:`RuleState.STATE_EDGE_NODE_VERSION_NOT_SUPPORTED`
            * :attr:`RuleState.STATE_NO_PNIC_SPECIFIED_IN_TN`
            * :attr:`RuleState.STATE_INVALID_PNIC_DEVICE_NAME`
            * :attr:`RuleState.STATE_TRANSPORT_NODE_READY`
            * :attr:`RuleState.STATE_VM_NETWORK_EDIT_PENDING`
            * :attr:`RuleState.STATE_UNSUPPORTED_DEFAULT_TEAMING_POLICY`
            * :attr:`RuleState.STATE_MPA_DISCONNECTED`
            * :attr:`RuleState.STATE_VM_RENAME_PENDING`
            * :attr:`RuleState.STATE_VM_CONFIG_EDIT_PENDING`
            * :attr:`RuleState.STATE_VM_NETWORK_EDIT_FAILED`
            * :attr:`RuleState.STATE_VM_RENAME_FAILED`
            * :attr:`RuleState.STATE_VM_CONFIG_EDIT_FAILED`
            * :attr:`RuleState.STATE_VM_CONFIG_DISCREPANCY`
            * :attr:`RuleState.STATE_VM_NODE_REFRESH_FAILED`
            * :attr:`RuleState.STATE_VM_PLACEMENT_REFRESH_FAILED`
            * :attr:`RuleState.STATE_REGISTRATION_TIMEDOUT`
            
            Gives details of state of desired configuration. Additional enums
            with more details on progress/success/error states are sent for
            edge node. The success states are NODE_READY and
            TRANSPORT_NODE_READY, pending states are {VM_DEPLOYMENT_QUEUED,
            VM_DEPLOYMENT_IN_PROGRESS, REGISTRATION_PENDING} and other values
            indicate failures. \"in_sync\" state indicates that the desired
            configuration has been received by the host to which it applies,
            but is not yet in effect. When the configuration is actually in
            effect, the state will change to \"success\". Please note, failed
            state is deprecated.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  revision_desired: :class:`long` or ``None``
        :param revision_desired: This attribute represents revision number of rule's desired state.
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  pending_change_list: :class:`list` of :class:`PendingChange` or ``None``
        :param pending_change_list: Pending changes to be realized.
        """
        self.details = details
        self.failure_code = failure_code
        self.failure_message = failure_message
        self.state = state
        self.revision_desired = revision_desired
        self.pending_change_list = pending_change_list
        VapiStruct.__init__(self)


RuleState._set_binding_type(type.StructType(
    'com.vmware.nsx.model.rule_state', {
        'details': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ConfigurationStateElement'))),
        'failure_code': type.OptionalType(type.IntegerType()),
        'failure_message': type.OptionalType(type.StringType()),
        'state': type.OptionalType(type.StringType()),
        'revision_desired': type.OptionalType(type.IntegerType()),
        'pending_change_list': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'PendingChange'))),
    },
    RuleState,
    False,
    None))



class RuntimeInterfaceOperationalStatus(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATUS_UP = "UP"
    """


    """
    STATUS_DOWN = "DOWN"
    """


    """
    STATUS_UNKNOWN = "UNKNOWN"
    """


    """



    _canonical_to_pep_names = {
                            'interface_index': 'interface_index',
                            'last_update_timestamp': 'last_update_timestamp',
                            'status': 'status',
                            }

    def __init__(self,
                 interface_index=None,
                 last_update_timestamp=None,
                 status=None,
                ):
        """
        :type  interface_index: :class:`long` or ``None``
        :param interface_index: Index of the interface format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_update_timestamp: :class:`long` or ``None``
        :param last_update_timestamp: Timestamp when the data was last updated; unset if data source has
            never updated the data. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  status: :class:`str` or ``None``
        :param status: Possible values are: 
            
            * :attr:`RuntimeInterfaceOperationalStatus.STATUS_UP`
            * :attr:`RuntimeInterfaceOperationalStatus.STATUS_DOWN`
            * :attr:`RuntimeInterfaceOperationalStatus.STATUS_UNKNOWN`
            
             The Operational status of the interface
        """
        self.interface_index = interface_index
        self.last_update_timestamp = last_update_timestamp
        self.status = status
        VapiStruct.__init__(self)


RuntimeInterfaceOperationalStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.runtime_interface_operational_status', {
        'interface_index': type.OptionalType(type.IntegerType()),
        'last_update_timestamp': type.OptionalType(type.IntegerType()),
        'status': type.OptionalType(type.StringType()),
    },
    RuntimeInterfaceOperationalStatus,
    False,
    None))



class RuntimeInterfaceStatistics(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'rx_bytes': 'rx_bytes',
                            'rx_packets': 'rx_packets',
                            'tx_bytes': 'tx_bytes',
                            'tx_packets': 'tx_packets',
                            'dropped_by_security_packets': 'dropped_by_security_packets',
                            'mac_learning': 'mac_learning',
                            'interface_index': 'interface_index',
                            'last_update_timestamp': 'last_update_timestamp',
                            }

    def __init__(self,
                 rx_bytes=None,
                 rx_packets=None,
                 tx_bytes=None,
                 tx_packets=None,
                 dropped_by_security_packets=None,
                 mac_learning=None,
                 interface_index=None,
                 last_update_timestamp=None,
                ):
        """
        :type  rx_bytes: :class:`SIDataCounter` or ``None``
        :param rx_bytes: 
        :type  rx_packets: :class:`SIDataCounter` or ``None``
        :param rx_packets: 
        :type  tx_bytes: :class:`SIDataCounter` or ``None``
        :param tx_bytes: 
        :type  tx_packets: :class:`SIDataCounter` or ``None``
        :param tx_packets: 
        :type  dropped_by_security_packets: :class:`SIPacketsDroppedBySecurity` or ``None``
        :param dropped_by_security_packets: 
        :type  mac_learning: :class:`SIMacLearningCounters` or ``None``
        :param mac_learning: 
        :type  interface_index: :class:`long` or ``None``
        :param interface_index: Index of the interface format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_update_timestamp: :class:`long` or ``None``
        :param last_update_timestamp: Timestamp when the data was last updated; unset if data source has
            never updated the data. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.rx_bytes = rx_bytes
        self.rx_packets = rx_packets
        self.tx_bytes = tx_bytes
        self.tx_packets = tx_packets
        self.dropped_by_security_packets = dropped_by_security_packets
        self.mac_learning = mac_learning
        self.interface_index = interface_index
        self.last_update_timestamp = last_update_timestamp
        VapiStruct.__init__(self)


RuntimeInterfaceStatistics._set_binding_type(type.StructType(
    'com.vmware.nsx.model.runtime_interface_statistics', {
        'rx_bytes': type.OptionalType(type.ReferenceType(__name__, 'SIDataCounter')),
        'rx_packets': type.OptionalType(type.ReferenceType(__name__, 'SIDataCounter')),
        'tx_bytes': type.OptionalType(type.ReferenceType(__name__, 'SIDataCounter')),
        'tx_packets': type.OptionalType(type.ReferenceType(__name__, 'SIDataCounter')),
        'dropped_by_security_packets': type.OptionalType(type.ReferenceType(__name__, 'SIPacketsDroppedBySecurity')),
        'mac_learning': type.OptionalType(type.ReferenceType(__name__, 'SIMacLearningCounters')),
        'interface_index': type.OptionalType(type.IntegerType()),
        'last_update_timestamp': type.OptionalType(type.IntegerType()),
    },
    RuntimeInterfaceStatistics,
    False,
    None))



class SIAggregatedDataCounter(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'rx_bytes': 'rx_bytes',
                            'rx_packets': 'rx_packets',
                            'tx_bytes': 'tx_bytes',
                            'tx_packets': 'tx_packets',
                            }

    def __init__(self,
                 rx_bytes=None,
                 rx_packets=None,
                 tx_bytes=None,
                 tx_packets=None,
                ):
        """
        :type  rx_bytes: :class:`SIDataCounter` or ``None``
        :param rx_bytes: 
        :type  rx_packets: :class:`SIDataCounter` or ``None``
        :param rx_packets: 
        :type  tx_bytes: :class:`SIDataCounter` or ``None``
        :param tx_bytes: 
        :type  tx_packets: :class:`SIDataCounter` or ``None``
        :param tx_packets: 
        """
        self.rx_bytes = rx_bytes
        self.rx_packets = rx_packets
        self.tx_bytes = tx_bytes
        self.tx_packets = tx_packets
        VapiStruct.__init__(self)


SIAggregatedDataCounter._set_binding_type(type.StructType(
    'com.vmware.nsx.model.SI_aggregated_data_counter', {
        'rx_bytes': type.OptionalType(type.ReferenceType(__name__, 'SIDataCounter')),
        'rx_packets': type.OptionalType(type.ReferenceType(__name__, 'SIDataCounter')),
        'tx_bytes': type.OptionalType(type.ReferenceType(__name__, 'SIDataCounter')),
        'tx_packets': type.OptionalType(type.ReferenceType(__name__, 'SIDataCounter')),
    },
    SIAggregatedDataCounter,
    False,
    None))



class SIAggregatedDataCounterEx(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'rx_bytes': 'rx_bytes',
                            'rx_packets': 'rx_packets',
                            'tx_bytes': 'tx_bytes',
                            'tx_packets': 'tx_packets',
                            'dropped_by_security_packets': 'dropped_by_security_packets',
                            'mac_learning': 'mac_learning',
                            }

    def __init__(self,
                 rx_bytes=None,
                 rx_packets=None,
                 tx_bytes=None,
                 tx_packets=None,
                 dropped_by_security_packets=None,
                 mac_learning=None,
                ):
        """
        :type  rx_bytes: :class:`SIDataCounter` or ``None``
        :param rx_bytes: 
        :type  rx_packets: :class:`SIDataCounter` or ``None``
        :param rx_packets: 
        :type  tx_bytes: :class:`SIDataCounter` or ``None``
        :param tx_bytes: 
        :type  tx_packets: :class:`SIDataCounter` or ``None``
        :param tx_packets: 
        :type  dropped_by_security_packets: :class:`SIPacketsDroppedBySecurity` or ``None``
        :param dropped_by_security_packets: 
        :type  mac_learning: :class:`SIMacLearningCounters` or ``None``
        :param mac_learning: 
        """
        self.rx_bytes = rx_bytes
        self.rx_packets = rx_packets
        self.tx_bytes = tx_bytes
        self.tx_packets = tx_packets
        self.dropped_by_security_packets = dropped_by_security_packets
        self.mac_learning = mac_learning
        VapiStruct.__init__(self)


SIAggregatedDataCounterEx._set_binding_type(type.StructType(
    'com.vmware.nsx.model.SI_aggregated_data_counter_ex', {
        'rx_bytes': type.OptionalType(type.ReferenceType(__name__, 'SIDataCounter')),
        'rx_packets': type.OptionalType(type.ReferenceType(__name__, 'SIDataCounter')),
        'tx_bytes': type.OptionalType(type.ReferenceType(__name__, 'SIDataCounter')),
        'tx_packets': type.OptionalType(type.ReferenceType(__name__, 'SIDataCounter')),
        'dropped_by_security_packets': type.OptionalType(type.ReferenceType(__name__, 'SIPacketsDroppedBySecurity')),
        'mac_learning': type.OptionalType(type.ReferenceType(__name__, 'SIMacLearningCounters')),
    },
    SIAggregatedDataCounterEx,
    False,
    None))



class SIDataCounter(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'dropped': 'dropped',
                            'multicast_broadcast': 'multicast_broadcast',
                            'total': 'total',
                            }

    def __init__(self,
                 dropped=None,
                 multicast_broadcast=None,
                 total=None,
                ):
        """
        :type  dropped: :class:`long` or ``None``
        :param dropped: The dropped packets or bytes format: int64
        :type  multicast_broadcast: :class:`long` or ``None``
        :param multicast_broadcast: The multicast and broadcast packets or bytes format: int64
        :type  total: :class:`long` or ``None``
        :param total: The total packets or bytes format: int64
        """
        self.dropped = dropped
        self.multicast_broadcast = multicast_broadcast
        self.total = total
        VapiStruct.__init__(self)


SIDataCounter._set_binding_type(type.StructType(
    'com.vmware.nsx.model.SI_data_counter', {
        'dropped': type.OptionalType(type.IntegerType()),
        'multicast_broadcast': type.OptionalType(type.IntegerType()),
        'total': type.OptionalType(type.IntegerType()),
    },
    SIDataCounter,
    False,
    None))



class SIErrorClass(VapiStruct):
    """
    Error class for all the Service Insertion related errors.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'error_id': 'error_id',
                            'error_message': 'error_message',
                            }

    def __init__(self,
                 error_id=None,
                 error_message=None,
                ):
        """
        :type  error_id: :class:`long` or ``None``
        :param error_id: 
        :type  error_message: :class:`str` or ``None``
        :param error_message: 
        """
        self.error_id = error_id
        self.error_message = error_message
        VapiStruct.__init__(self)


SIErrorClass._set_binding_type(type.StructType(
    'com.vmware.nsx.model.SI_error_class', {
        'error_id': type.OptionalType(type.IntegerType()),
        'error_message': type.OptionalType(type.StringType()),
    },
    SIErrorClass,
    False,
    None))



class SIExcludeList(VapiStruct):
    """
    List of entities where Service Insertion will not be enforced. Exclusion
    List can contain NSGroup(s) or LogicalPort(s) or LogicalSwitch(es).

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'member_count': 'member_count',
                            'members': 'members',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 member_count=None,
                 members=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  member_count: :class:`long` or ``None``
        :param member_count: Total number of members present in Exclude List. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  members: :class:`list` of :class:`ResourceReference` or ``None``
        :param members: List of members in Exclusion List
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.member_count = member_count
        self.members = members
        VapiStruct.__init__(self)


SIExcludeList._set_binding_type(type.StructType(
    'com.vmware.nsx.model.SI_exclude_list', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'member_count': type.OptionalType(type.IntegerType()),
        'members': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceReference'))),
    },
    SIExcludeList,
    False,
    None))



class SIMacLearningCounters(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'mac_not_learned_packets_allowed': 'mac_not_learned_packets_allowed',
                            'mac_not_learned_packets_dropped': 'mac_not_learned_packets_dropped',
                            'macs_learned': 'macs_learned',
                            }

    def __init__(self,
                 mac_not_learned_packets_allowed=None,
                 mac_not_learned_packets_dropped=None,
                 macs_learned=None,
                ):
        """
        :type  mac_not_learned_packets_allowed: :class:`long` or ``None``
        :param mac_not_learned_packets_allowed: The number of packets with unknown source MAC address that are
            dispatched without learning the source MAC address. Applicable only
            when the MAC limit is reached and MAC Limit policy is
            MAC_LEARNING_LIMIT_POLICY_ALLOW. format: int64
        :type  mac_not_learned_packets_dropped: :class:`long` or ``None``
        :param mac_not_learned_packets_dropped: The number of packets with unknown source MAC address that are
            dropped without learning the source MAC address. Applicable only
            when the MAC limit is reached and MAC Limit policy is
            MAC_LEARNING_LIMIT_POLICY_DROP. format: int64
        :type  macs_learned: :class:`long` or ``None``
        :param macs_learned: Number of MACs learned format: int64
        """
        self.mac_not_learned_packets_allowed = mac_not_learned_packets_allowed
        self.mac_not_learned_packets_dropped = mac_not_learned_packets_dropped
        self.macs_learned = macs_learned
        VapiStruct.__init__(self)


SIMacLearningCounters._set_binding_type(type.StructType(
    'com.vmware.nsx.model.SI_mac_learning_counters', {
        'mac_not_learned_packets_allowed': type.OptionalType(type.IntegerType()),
        'mac_not_learned_packets_dropped': type.OptionalType(type.IntegerType()),
        'macs_learned': type.OptionalType(type.IntegerType()),
    },
    SIMacLearningCounters,
    False,
    None))



class SIPacketTypeAndCounter(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'counter': 'counter',
                            'packet_type': 'packet_type',
                            }

    def __init__(self,
                 counter=None,
                 packet_type=None,
                ):
        """
        :type  counter: :class:`long` or ``None``
        :param counter: The number of packets. format: int64
        :type  packet_type: :class:`str` or ``None``
        :param packet_type: The type of the packets
        """
        self.counter = counter
        self.packet_type = packet_type
        VapiStruct.__init__(self)


SIPacketTypeAndCounter._set_binding_type(type.StructType(
    'com.vmware.nsx.model.SI_packet_type_and_counter', {
        'counter': type.OptionalType(type.IntegerType()),
        'packet_type': type.OptionalType(type.StringType()),
    },
    SIPacketTypeAndCounter,
    False,
    None))



class SIPacketsDroppedBySecurity(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'bpdu_filter_dropped': 'bpdu_filter_dropped',
                            'dhcp_client_dropped_ipv4': 'dhcp_client_dropped_ipv4',
                            'dhcp_client_dropped_ipv6': 'dhcp_client_dropped_ipv6',
                            'dhcp_server_dropped_ipv4': 'dhcp_server_dropped_ipv4',
                            'dhcp_server_dropped_ipv6': 'dhcp_server_dropped_ipv6',
                            'spoof_guard_dropped': 'spoof_guard_dropped',
                            }

    def __init__(self,
                 bpdu_filter_dropped=None,
                 dhcp_client_dropped_ipv4=None,
                 dhcp_client_dropped_ipv6=None,
                 dhcp_server_dropped_ipv4=None,
                 dhcp_server_dropped_ipv6=None,
                 spoof_guard_dropped=None,
                ):
        """
        :type  bpdu_filter_dropped: :class:`long` or ``None``
        :param bpdu_filter_dropped: The number of packets dropped by \"BPDU filter\". format: int64
        :type  dhcp_client_dropped_ipv4: :class:`long` or ``None``
        :param dhcp_client_dropped_ipv4: The number of IPv4 packets dropped by \"DHCP client block\".
            format: int64
        :type  dhcp_client_dropped_ipv6: :class:`long` or ``None``
        :param dhcp_client_dropped_ipv6: The number of IPv6 packets dropped by \"DHCP client block\".
            format: int64
        :type  dhcp_server_dropped_ipv4: :class:`long` or ``None``
        :param dhcp_server_dropped_ipv4: The number of IPv4 packets dropped by \"DHCP server block\".
            format: int64
        :type  dhcp_server_dropped_ipv6: :class:`long` or ``None``
        :param dhcp_server_dropped_ipv6: The number of IPv6 packets dropped by \"DHCP server block\".
            format: int64
        :type  spoof_guard_dropped: :class:`list` of :class:`SIPacketTypeAndCounter` or ``None``
        :param spoof_guard_dropped: The packets dropped by \"Spoof Guard\"; supported packet types are
            IPv4, IPv6, ARP, ND, non-IP.
        """
        self.bpdu_filter_dropped = bpdu_filter_dropped
        self.dhcp_client_dropped_ipv4 = dhcp_client_dropped_ipv4
        self.dhcp_client_dropped_ipv6 = dhcp_client_dropped_ipv6
        self.dhcp_server_dropped_ipv4 = dhcp_server_dropped_ipv4
        self.dhcp_server_dropped_ipv6 = dhcp_server_dropped_ipv6
        self.spoof_guard_dropped = spoof_guard_dropped
        VapiStruct.__init__(self)


SIPacketsDroppedBySecurity._set_binding_type(type.StructType(
    'com.vmware.nsx.model.SI_packets_dropped_by_security', {
        'bpdu_filter_dropped': type.OptionalType(type.IntegerType()),
        'dhcp_client_dropped_ipv4': type.OptionalType(type.IntegerType()),
        'dhcp_client_dropped_ipv6': type.OptionalType(type.IntegerType()),
        'dhcp_server_dropped_ipv4': type.OptionalType(type.IntegerType()),
        'dhcp_server_dropped_ipv6': type.OptionalType(type.IntegerType()),
        'spoof_guard_dropped': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'SIPacketTypeAndCounter'))),
    },
    SIPacketsDroppedBySecurity,
    False,
    None))



class SIServiceProfileListResult(VapiStruct):
    """
    Service Insertion Service Profile List

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param results: List of the Service-Insertion Services. The list has to be
            homogenous.
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`BaseServiceProfile`. When methods return a value of this
            class as a return value, the attribute will contain all the
            attributes defined in :class:`BaseServiceProfile`.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


SIServiceProfileListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.SI_service_profile_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'BaseServiceProfile')]))),
    },
    SIServiceProfileListResult,
    False,
    None))



class SVMConfigureIssue(VapiStruct):
    """
    Type of issue and detailed description of the issues in case of post-VM
    deployment configuration failure.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'errors': 'errors',
                            'service_instance_id': 'service_instance_id',
                            }

    def __init__(self,
                 errors=None,
                 service_instance_id=None,
                ):
        """
        :type  errors: :class:`list` of :class:`SIErrorClass` or ``None``
        :param errors: List of errors along with details like errorId and error messages.
        :type  service_instance_id: :class:`str` or ``None``
        :param service_instance_id: The ID of service instance which was deployed.
        """
        self.errors = errors
        self.service_instance_id = service_instance_id
        VapiStruct.__init__(self)


SVMConfigureIssue._set_binding_type(type.StructType(
    'com.vmware.nsx.model.SVM_configure_issue', {
        'errors': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'SIErrorClass'))),
        'service_instance_id': type.OptionalType(type.StringType()),
    },
    SVMConfigureIssue,
    False,
    None))



class SVMDeploymentSpec(VapiStruct):
    """
    Deployment Specs holds information required to deploy the Service-VMs.i.e.
    OVF url where the partner Service-VM OVF is hosted. The host type on which
    the OVF(Open Virtualization Format) can be deployed, Form factor to name a
    few.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    HOST_TYPE_ESXI = "ESXI"
    """


    """
    HOST_TYPE_RHELKVM = "RHELKVM"
    """


    """
    HOST_TYPE_UBUNTUKVM = "UBUNTUKVM"
    """


    """
    SERVICE_FORM_FACTOR_SMALL = "SMALL"
    """


    """
    SERVICE_FORM_FACTOR_MEDIUM = "MEDIUM"
    """


    """
    SERVICE_FORM_FACTOR_LARGE = "LARGE"
    """


    """



    _canonical_to_pep_names = {
                            'host_type': 'host_type',
                            'min_host_version': 'min_host_version',
                            'name': 'name',
                            'ovf_url': 'ovf_url',
                            'service_form_factor': 'service_form_factor',
                            'svm_version': 'svm_version',
                            }

    def __init__(self,
                 host_type=None,
                 min_host_version=None,
                 name=None,
                 ovf_url=None,
                 service_form_factor=None,
                 svm_version=None,
                ):
        """
        :type  host_type: :class:`str` or ``None``
        :param host_type: Possible values are: 
            
            * :attr:`SVMDeploymentSpec.HOST_TYPE_ESXI`
            * :attr:`SVMDeploymentSpec.HOST_TYPE_RHELKVM`
            * :attr:`SVMDeploymentSpec.HOST_TYPE_UBUNTUKVM`
            
             Host Type on which the specified OVF can be deployed.
        :type  min_host_version: :class:`str` or ``None``
        :param min_host_version: Minimum host version supported by this ovf. If a host in the
            deployment cluster is having version less than this, then service
            deployment will not happen on that host.
        :type  name: :class:`str` or ``None``
        :param name: Deployment Spec name for ease of use, since multiple DeploymentSpec
            can be specified.
        :type  ovf_url: :class:`str` or ``None``
        :param ovf_url: Location of the partner VM OVF to be deployed.
        :type  service_form_factor: :class:`str` or ``None``
        :param service_form_factor: Possible values are: 
            
            * :attr:`SVMDeploymentSpec.SERVICE_FORM_FACTOR_SMALL`
            * :attr:`SVMDeploymentSpec.SERVICE_FORM_FACTOR_MEDIUM`
            * :attr:`SVMDeploymentSpec.SERVICE_FORM_FACTOR_LARGE`
            
            Supported ServiceInsertion Form Factor for the OVF deployment. The
            default FormFactor is Medium.
        :type  svm_version: :class:`str` or ``None``
        :param svm_version: Partner needs to specify the Service VM version which will get
            deployed.
        """
        self.host_type = host_type
        self.min_host_version = min_host_version
        self.name = name
        self.ovf_url = ovf_url
        self.service_form_factor = service_form_factor
        self.svm_version = svm_version
        VapiStruct.__init__(self)


SVMDeploymentSpec._set_binding_type(type.StructType(
    'com.vmware.nsx.model.SVM_deployment_spec', {
        'host_type': type.OptionalType(type.StringType()),
        'min_host_version': type.OptionalType(type.StringType()),
        'name': type.OptionalType(type.StringType()),
        'ovf_url': type.OptionalType(type.StringType()),
        'service_form_factor': type.OptionalType(type.StringType()),
        'svm_version': type.OptionalType(type.StringType()),
    },
    SVMDeploymentSpec,
    False,
    None))



class ScpProtocol(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "ScpProtocol"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'authentication_scheme': 'authentication_scheme',
                            'ssh_fingerprint': 'ssh_fingerprint',
                            'name': 'name',
                            }

    def __init__(self,
                 authentication_scheme=None,
                 ssh_fingerprint=None,
                 name='ScpProtocol',
                ):
        """
        :type  authentication_scheme: :class:`PasswordAuthenticationScheme` or ``None``
        :param authentication_scheme: Scheme to authenticate if required
        :type  ssh_fingerprint: :class:`str` or ``None``
        :param ssh_fingerprint: SSH fingerprint of server
        :type  name: :class:`str`
        :param name: Possible values are: 
            
            * :attr:`Protocol.NAME_HTTP`
            * :attr:`Protocol.NAME_HTTPS`
            * :attr:`Protocol.NAME_SCP`
            * :attr:`Protocol.NAME_SFTP`
            
             Protocol name
        """
        self.authentication_scheme = authentication_scheme
        self.ssh_fingerprint = ssh_fingerprint
        self._name = name
        VapiStruct.__init__(self)

    @property
    def name(self):
        """
        Return the discriminator value
        """
        return self._name

ScpProtocol._set_binding_type(type.StructType(
    'com.vmware.nsx.model.scp_protocol', {
        'authentication_scheme': type.OptionalType(type.ReferenceType(__name__, 'PasswordAuthenticationScheme')),
        'ssh_fingerprint': type.OptionalType(type.StringType()),
        'name': type.StringType(),
    },
    ScpProtocol,
    False,
    None))



class SearchResponse(VapiStruct):
    """
    Search response

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param results: List of records matching the search query.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


SearchResponse._set_binding_type(type.StructType(
    'com.vmware.nsx.model.search_response', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct))),
    },
    SearchResponse,
    False,
    None))



class SecurityCertificate(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'pem_encoded': 'pem_encoded',
                            'ssh_public_key': 'ssh_public_key',
                            'text': 'text',
                            'valid_from': 'valid_from',
                            'valid_to': 'valid_to',
                            }

    def __init__(self,
                 pem_encoded=None,
                 ssh_public_key=None,
                 text=None,
                 valid_from=None,
                 valid_to=None,
                ):
        """
        :type  pem_encoded: :class:`str` or ``None``
        :param pem_encoded: The certificate must include the enclosing \"-----BEGIN
            CERTIFICATE-----\" and \"-----END CERTIFICATE-----\"
        :type  ssh_public_key: :class:`str` or ``None``
        :param ssh_public_key: 
        :type  text: :class:`str` or ``None``
        :param text: X.509 certificate in text form
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  valid_from: :class:`str` or ``None``
        :param valid_from: The time when the certificate starts being valid
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  valid_to: :class:`str` or ``None``
        :param valid_to: The time when the certificate stops being valid
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.pem_encoded = pem_encoded
        self.ssh_public_key = ssh_public_key
        self.text = text
        self.valid_from = valid_from
        self.valid_to = valid_to
        VapiStruct.__init__(self)


SecurityCertificate._set_binding_type(type.StructType(
    'com.vmware.nsx.model.security_certificate', {
        'pem_encoded': type.OptionalType(type.StringType()),
        'ssh_public_key': type.OptionalType(type.StringType()),
        'text': type.OptionalType(type.StringType()),
        'valid_from': type.OptionalType(type.StringType()),
        'valid_to': type.OptionalType(type.StringType()),
    },
    SecurityCertificate,
    False,
    None))



class SecurityGlobalConfig(VapiStruct):
    """
    NSX global configs for security purposes, like trust store and trust
    manager.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "SecurityGlobalConfig"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'ca_signed_only': 'ca_signed_only',
                            'crl_checking_enabled': 'crl_checking_enabled',
                            'eku_checking_enabled': 'eku_checking_enabled',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            }

    def __init__(self,
                 ca_signed_only=None,
                 crl_checking_enabled=None,
                 eku_checking_enabled=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='SecurityGlobalConfig',
                 tags=None,
                ):
        """
        :type  ca_signed_only: :class:`bool` or ``None``
        :param ca_signed_only: When this flag is set to true (for NDcPP compliance) only ca-signed
            certificates will be allowed to be applied as server certificates.
        :type  crl_checking_enabled: :class:`bool` or ``None``
        :param crl_checking_enabled: When this flag is set to true, during certificate checking the CRL
            is fetched and checked whether the certificate is revoked or not.
        :type  eku_checking_enabled: :class:`bool` or ``None``
        :param eku_checking_enabled: When this flag is set to true, during certificate checking the
            Extended Key Usage extension is expected to be present, indicating
            whether the certificate is to be used a client certificate or
            server certificate. Setting this value to false is not recommended
            as it leads to lower security and operational risk.
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`GlobalConfigs.RESOURCE_TYPE_SWITCHINGGLOBALCONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_ROUTINGGLOBALCONFIG`
            *
              :attr:`GlobalConfigs.RESOURCE_TYPE_OPERATIONCOLLECTORGLOBALCONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_FIREWALLGLOBALCONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_ESXGLOBALOPAQUECONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_SECURITYGLOBALCONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_FIPSGLOBALCONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_FEDERATIONGLOBALCONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_IDSGLOBALCONFIG`
            
             Valid Global configuration types
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        """
        self.ca_signed_only = ca_signed_only
        self.crl_checking_enabled = crl_checking_enabled
        self.eku_checking_enabled = eku_checking_enabled
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

SecurityGlobalConfig._set_binding_type(type.StructType(
    'com.vmware.nsx.model.security_global_config', {
        'ca_signed_only': type.OptionalType(type.BooleanType()),
        'crl_checking_enabled': type.OptionalType(type.BooleanType()),
        'eku_checking_enabled': type.OptionalType(type.BooleanType()),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
    },
    SecurityGlobalConfig,
    False,
    None))



class SelectableResourceReference(VapiStruct):
    """
    Resources to take action on

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'is_valid': 'is_valid',
                            'target_display_name': 'target_display_name',
                            'target_id': 'target_id',
                            'target_type': 'target_type',
                            'selected': 'selected',
                            }

    def __init__(self,
                 is_valid=None,
                 target_display_name=None,
                 target_id=None,
                 target_type=None,
                 selected=None,
                ):
        """
        :type  is_valid: :class:`bool` or ``None``
        :param is_valid: Will be set to false if the referenced NSX resource has been
            deleted.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  target_display_name: :class:`str` or ``None``
        :param target_display_name: Display name of the NSX resource.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  target_id: :class:`str` or ``None``
        :param target_id: Identifier of the NSX resource.
        :type  target_type: :class:`str` or ``None``
        :param target_type: Type of the NSX resource.
        :type  selected: :class:`bool` or ``None``
        :param selected: Set to true if this resource has been selected to be acted upon
        """
        self.is_valid = is_valid
        self.target_display_name = target_display_name
        self.target_id = target_id
        self.target_type = target_type
        self.selected = selected
        VapiStruct.__init__(self)


SelectableResourceReference._set_binding_type(type.StructType(
    'com.vmware.nsx.model.selectable_resource_reference', {
        'is_valid': type.OptionalType(type.BooleanType()),
        'target_display_name': type.OptionalType(type.StringType()),
        'target_id': type.OptionalType(type.StringType()),
        'target_type': type.OptionalType(type.StringType()),
        'selected': type.OptionalType(type.BooleanType()),
    },
    SelectableResourceReference,
    False,
    None))



class SelectiveSyncSettings(VapiStruct):
    """
    Directory domain selective sync settings

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'enabled': 'enabled',
                            'selected_org_units': 'selected_org_units',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 enabled=None,
                 selected_org_units=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  enabled: :class:`bool` or ``None``
        :param enabled: Enable or disable SelectiveSync
        :type  selected_org_units: :class:`list` of :class:`str` or ``None``
        :param selected_org_units: If SelectiveSync is enabled, this contains 1 or more OrgUnits,
            which NSX will synchronize with in LDAP server. The full
            distiguished name (DN) should be used for OrgUnit. If SelectiveSync
            is disabled, do not define this or specify an empty list.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.enabled = enabled
        self.selected_org_units = selected_org_units
        VapiStruct.__init__(self)


SelectiveSyncSettings._set_binding_type(type.StructType(
    'com.vmware.nsx.model.selective_sync_settings', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'enabled': type.OptionalType(type.BooleanType()),
        'selected_org_units': type.OptionalType(type.ListType(type.StringType())),
    },
    SelectiveSyncSettings,
    False,
    None))



class SelfResourceLink(VapiStruct):
    """
    The server will populate this field when returing the resource. Ignored on
    PUT and POST.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'action': 'action',
                            'href': 'href',
                            'rel': 'rel',
                            }

    def __init__(self,
                 action=None,
                 href=None,
                 rel=None,
                ):
        """
        :type  action: :class:`str` or ``None``
        :param action: Optional action
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  href: :class:`str` or ``None``
        :param href: Link to resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  rel: :class:`str` or ``None``
        :param rel: Custom relation type (follows RFC 5988 where appropriate
            definitions exist)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.action = action
        self.href = href
        self.rel = rel
        VapiStruct.__init__(self)


SelfResourceLink._set_binding_type(type.StructType(
    'com.vmware.nsx.model.self_resource_link', {
        'action': type.OptionalType(type.StringType()),
        'href': type.OptionalType(type.StringType()),
        'rel': type.OptionalType(type.StringType()),
    },
    SelfResourceLink,
    False,
    None))



class ServerSslProfileBinding(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    SERVER_AUTH_REQUIRED = "REQUIRED"
    """


    """
    SERVER_AUTH_IGNORE = "IGNORE"
    """


    """



    _canonical_to_pep_names = {
                            'certificate_chain_depth': 'certificate_chain_depth',
                            'client_certificate_id': 'client_certificate_id',
                            'server_auth': 'server_auth',
                            'server_auth_ca_ids': 'server_auth_ca_ids',
                            'server_auth_crl_ids': 'server_auth_crl_ids',
                            'ssl_profile_id': 'ssl_profile_id',
                            }

    def __init__(self,
                 certificate_chain_depth=None,
                 client_certificate_id=None,
                 server_auth=None,
                 server_auth_ca_ids=None,
                 server_auth_crl_ids=None,
                 ssl_profile_id=None,
                ):
        """
        :type  certificate_chain_depth: :class:`long` or ``None``
        :param certificate_chain_depth: authentication depth is used to set the verification depth in the
            server certificates chain. format: int64
        :type  client_certificate_id: :class:`str` or ``None``
        :param client_certificate_id: To support client authentication (load balancer acting as a client
            authenticating to the backend server), client certificate can be
            specified in the server-side SSL profile binding
        :type  server_auth: :class:`str` or ``None``
        :param server_auth: Possible values are: 
            
            * :attr:`ServerSslProfileBinding.SERVER_AUTH_REQUIRED`
            * :attr:`ServerSslProfileBinding.SERVER_AUTH_IGNORE`
            
             server authentication mode
        :type  server_auth_ca_ids: :class:`list` of :class:`str` or ``None``
        :param server_auth_ca_ids: If server auth type is REQUIRED, server certificate must be signed
            by one of the trusted Certificate Authorities (CAs), also referred
            to as root CAs, whose self signed certificates are specified.
        :type  server_auth_crl_ids: :class:`list` of :class:`str` or ``None``
        :param server_auth_crl_ids: A Certificate Revocation List (CRL) can be specified in the
            server-side SSL profile binding to disallow compromised server
            certificates.
        :type  ssl_profile_id: :class:`str` or ``None``
        :param ssl_profile_id: Server SSL profile defines reusable, application-independent server
            side SSL properties.
        """
        self.certificate_chain_depth = certificate_chain_depth
        self.client_certificate_id = client_certificate_id
        self.server_auth = server_auth
        self.server_auth_ca_ids = server_auth_ca_ids
        self.server_auth_crl_ids = server_auth_crl_ids
        self.ssl_profile_id = ssl_profile_id
        VapiStruct.__init__(self)


ServerSslProfileBinding._set_binding_type(type.StructType(
    'com.vmware.nsx.model.server_ssl_profile_binding', {
        'certificate_chain_depth': type.OptionalType(type.IntegerType()),
        'client_certificate_id': type.OptionalType(type.StringType()),
        'server_auth': type.OptionalType(type.StringType()),
        'server_auth_ca_ids': type.OptionalType(type.ListType(type.StringType())),
        'server_auth_crl_ids': type.OptionalType(type.ListType(type.StringType())),
        'ssl_profile_id': type.OptionalType(type.StringType()),
    },
    ServerSslProfileBinding,
    False,
    None))



class ServiceAssociationListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "ServiceAssociationListResult"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    SERVICE_TYPE_FIREWALLSERVICEASSOCIATIONLISTRESULT = "FireWallServiceAssociationListResult"
    """


    """
    SERVICE_TYPE_IPFIXSERVICEASSOCIATIONLISTRESULT = "IpfixServiceAssociationListResult"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'service_type': 'service_type',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 service_type='ServiceAssociationListResult',
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  service_type: :class:`str`
        :param service_type: Possible values are: 
            
            *
              :attr:`ServiceAssociationListResult.SERVICE_TYPE_FIREWALLSERVICEASSOCIATIONLISTRESULT`
            *
              :attr:`ServiceAssociationListResult.SERVICE_TYPE_IPFIXSERVICEASSOCIATIONLISTRESULT`
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self._service_type = service_type
        VapiStruct.__init__(self)

    @property
    def service_type(self):
        """
        Return the discriminator value
        """
        return self._service_type

ServiceAssociationListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.service_association_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'service_type': type.StringType(),
    },
    ServiceAssociationListResult,
    False,
    None))



class ServiceAttachment(VapiStruct):
    """
    A ServiceAttachment represents a point on NSX entity (Example - Edge
    Router) to which ServiceInstance can be connected through an
    InstanceEndpoint. Example - In VMWare Hybric Cloud Extention (HCX) use
    case, HCX appliances connect to this Service Attachment Point. We do not
    handle the lifecycle of these appliance/s.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    ATTACHMENT_STATUS_UP = "UP"
    """


    """
    ATTACHMENT_STATUS_DOWN = "DOWN"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'attachment_status': 'attachment_status',
                            'deployed_to': 'deployed_to',
                            'local_ips': 'local_ips',
                            'logical_routers': 'logical_routers',
                            'logical_switch': 'logical_switch',
                            'service_port': 'service_port',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 attachment_status=None,
                 deployed_to=None,
                 local_ips=None,
                 logical_routers=None,
                 logical_switch=None,
                 service_port=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  attachment_status: :class:`str` or ``None``
        :param attachment_status: Possible values are: 
            
            * :attr:`ServiceAttachment.ATTACHMENT_STATUS_UP`
            * :attr:`ServiceAttachment.ATTACHMENT_STATUS_DOWN`
            
            UP - A Service Attachment will have its Service Port - UP and with
            a configured IP address. DOWN - An Inactive ServiceAttachment has
            its Service Port - DOWN. It can be used to connect set of
            appliances that do not need to exchange traffic to/from/through the
            Edge node.
        :type  deployed_to: :class:`ResourceReference` or ``None``
        :param deployed_to: NSX Resource where we want to create Service Attachment Point. Ex.
            T0 LR Edge in case of north-south ServiceInsertion and a
            TransportZone (which is used to define the service plane) in case
            of east-west service insertion.
        :type  local_ips: :class:`list` of :class:`IPInfo` or ``None``
        :param local_ips: Local IPs associated with this Service Attachment.
        :type  logical_routers: :class:`list` of :class:`ResourceReference` or ``None``
        :param logical_routers: List of LogicalRouters to be connected to the ServicePlane logical
            switch via a ServiceLink.
        :type  logical_switch: :class:`ResourceReference` or ``None``
        :param logical_switch: Logical Switch gets created as a part of Service Attachment
            creation.
        :type  service_port: :class:`ResourceReference` or ``None``
        :param service_port: Service Port gets created as a part of Service Attachment creation.
            It is a Logical Router Port of type CentralizedServicePort. It does
            not participate in distributed routing. Stateless Policy Based
            Routing service can be applied on this port.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.attachment_status = attachment_status
        self.deployed_to = deployed_to
        self.local_ips = local_ips
        self.logical_routers = logical_routers
        self.logical_switch = logical_switch
        self.service_port = service_port
        VapiStruct.__init__(self)


ServiceAttachment._set_binding_type(type.StructType(
    'com.vmware.nsx.model.service_attachment', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'attachment_status': type.OptionalType(type.StringType()),
        'deployed_to': type.OptionalType(type.ReferenceType(__name__, 'ResourceReference')),
        'local_ips': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IPInfo'))),
        'logical_routers': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceReference'))),
        'logical_switch': type.OptionalType(type.ReferenceType(__name__, 'ResourceReference')),
        'service_port': type.OptionalType(type.ReferenceType(__name__, 'ResourceReference')),
    },
    ServiceAttachment,
    False,
    None))



class ServiceAttachmentListResult(VapiStruct):
    """
    List of Service Attachments.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`ServiceAttachment` or ``None``
        :param results: List of the Service Attachments.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


ServiceAttachmentListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.service_attachment_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ServiceAttachment'))),
    },
    ServiceAttachmentListResult,
    False,
    None))



class ServiceBinding(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'service_id': 'service_id',
                            }

    def __init__(self,
                 service_id=None,
                ):
        """
        :type  service_id: :class:`ResourceReference` or ``None``
        :param service_id: Identifier of Logical Service
        """
        self.service_id = service_id
        VapiStruct.__init__(self)


ServiceBinding._set_binding_type(type.StructType(
    'com.vmware.nsx.model.service_binding', {
        'service_id': type.OptionalType(type.ReferenceType(__name__, 'ResourceReference')),
    },
    ServiceBinding,
    False,
    None))



class ServiceCapability(VapiStruct):
    """
    Service capabilities that will be inherited by service VMs created using a
    service definition that contains this service capability.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'can_decrement_si': 'can_decrement_si',
                            'nsh_liveness_support_enabled': 'nsh_liveness_support_enabled',
                            }

    def __init__(self,
                 can_decrement_si=None,
                 nsh_liveness_support_enabled=None,
                ):
        """
        :type  can_decrement_si: :class:`bool` or ``None``
        :param can_decrement_si: Indicating whether service is configured to decrement SI field in
            NSH metadata.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  nsh_liveness_support_enabled: :class:`bool` or ``None``
        :param nsh_liveness_support_enabled: Indicating whether service supports NSH liveness detection.
        """
        self.can_decrement_si = can_decrement_si
        self.nsh_liveness_support_enabled = nsh_liveness_support_enabled
        VapiStruct.__init__(self)


ServiceCapability._set_binding_type(type.StructType(
    'com.vmware.nsx.model.service_capability', {
        'can_decrement_si': type.OptionalType(type.BooleanType()),
        'nsh_liveness_support_enabled': type.OptionalType(type.BooleanType()),
    },
    ServiceCapability,
    False,
    None))



class ServiceChain(VapiStruct):
    """
    Service chain is a set of network Services. A Service chain is made up of
    ordered list of service profiles belonging to any same or different
    services.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    ON_FAILURE_POLICY_ALLOW = "ALLOW"
    """


    """
    ON_FAILURE_POLICY_BLOCK = "BLOCK"
    """


    """
    PATH_SELECTION_POLICY_ANY = "ANY"
    """


    """
    PATH_SELECTION_POLICY_LOCAL = "LOCAL"
    """


    """
    PATH_SELECTION_POLICY_REMOTE = "REMOTE"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'forward_path_service_profiles': 'forward_path_service_profiles',
                            'on_failure_policy': 'on_failure_policy',
                            'path_selection_policy': 'path_selection_policy',
                            'reverse_path_service_profiles': 'reverse_path_service_profiles',
                            'service_attachments': 'service_attachments',
                            'service_chain_id': 'service_chain_id',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 forward_path_service_profiles=None,
                 on_failure_policy=None,
                 path_selection_policy=None,
                 reverse_path_service_profiles=None,
                 service_attachments=None,
                 service_chain_id=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  forward_path_service_profiles: :class:`list` of :class:`ResourceReference` or ``None``
        :param forward_path_service_profiles: List of ServiceInsertionServiceProfiles that constitutes the the
            service chain. The forward path service profiles are applied to
            ingress traffic.
        :type  on_failure_policy: :class:`str` or ``None``
        :param on_failure_policy: Possible values are: 
            
            * :attr:`ServiceChain.ON_FAILURE_POLICY_ALLOW`
            * :attr:`ServiceChain.ON_FAILURE_POLICY_BLOCK`
            
            Failure policy for the service tells datapath, the action to take
            i.e to allow or block traffic during failure scenarios.
        :type  path_selection_policy: :class:`str` or ``None``
        :param path_selection_policy: Possible values are: 
            
            * :attr:`ServiceChain.PATH_SELECTION_POLICY_ANY`
            * :attr:`ServiceChain.PATH_SELECTION_POLICY_LOCAL`
            * :attr:`ServiceChain.PATH_SELECTION_POLICY_REMOTE`
            
            Path selection policy can be - ANY - Service Insertion is free to
            redirect to any service path regardless of any load balancing
            considerations or flow pinning. LOCAL - means to prefer local
            service insances. REMOTE - preference is to redirect to the SVM
            co-located on the same host.
        :type  reverse_path_service_profiles: :class:`list` of :class:`ResourceReference` or ``None``
        :param reverse_path_service_profiles: List of ServiceInsertionServiceProfiles id. Reverse path service
            profiles are applied to egress traffic and is optional. 2 different
            set of profiles can be defined for forward and reverse path. If not
            defined, the reverse of the forward path service profile is
            applied.
        :type  service_attachments: :class:`list` of :class:`ResourceReference` or ``None``
        :param service_attachments: Service attachment specifies the scope i.e Service plane at which
            the SVMs are deployed.
        :type  service_chain_id: :class:`str` or ``None``
        :param service_chain_id: A unique id generated for every service chain. This is not a uuid.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.forward_path_service_profiles = forward_path_service_profiles
        self.on_failure_policy = on_failure_policy
        self.path_selection_policy = path_selection_policy
        self.reverse_path_service_profiles = reverse_path_service_profiles
        self.service_attachments = service_attachments
        self.service_chain_id = service_chain_id
        VapiStruct.__init__(self)


ServiceChain._set_binding_type(type.StructType(
    'com.vmware.nsx.model.service_chain', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'forward_path_service_profiles': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceReference'))),
        'on_failure_policy': type.OptionalType(type.StringType()),
        'path_selection_policy': type.OptionalType(type.StringType()),
        'reverse_path_service_profiles': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceReference'))),
        'service_attachments': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceReference'))),
        'service_chain_id': type.OptionalType(type.StringType()),
    },
    ServiceChain,
    False,
    None))



class ServiceChainListResult(VapiStruct):
    """
    Service Chain List

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`ServiceChain` or ``None``
        :param results: List of the Service-Insertion Services. The list has to be
            homogenous.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


ServiceChainListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.service_chain_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ServiceChain'))),
    },
    ServiceChainListResult,
    False,
    None))



class ServiceChainMapping(VapiStruct):
    """
    A ServiceInsertionServiceProfile can be part of multiple ServiceChains.
    ServiceChainMapping for a particular profile will contain a list of all the
    ServiceChains it's part of. Each Mapping will also contain some metadata to
    uniquely identify a profile from other profiles.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    DIRECTION_FORWARD = "FORWARD"
    """


    """
    DIRECTION_REVERSE = "REVERSE"
    """


    """



    _canonical_to_pep_names = {
                            'direction': 'direction',
                            'service_chain_id': 'service_chain_id',
                            'service_index': 'service_index',
                            }

    def __init__(self,
                 direction=None,
                 service_chain_id=None,
                 service_index=None,
                ):
        """
        :type  direction: :class:`str` or ``None``
        :param direction: Possible values are: 
            
            * :attr:`ServiceChainMapping.DIRECTION_FORWARD`
            * :attr:`ServiceChainMapping.DIRECTION_REVERSE`
            
            Each ServiceChain has forward_path_service_profiles and
            reverse_path_service_profiles. This property will indicate which of
            them being used. FORWARD - forward_path_service_profiles REVERSE -
            reverse_path_service_profiles
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  service_chain_id: :class:`str` or ``None``
        :param service_chain_id: A unique id generated for every ServiceChain. This is not a uuid.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  service_index: :class:`long` or ``None``
        :param service_index: Service Index represents a numerical position of a
            ServiceInsertionServiceProfile in a ServiceChain. It will be in
            reverse order. Service Index can point to either
            forward_path_service_profiles or reverse_path_service_profiles
            indicated by direction property. Example - For a ServiceChain
            A-B-C, A will have index of 3, B will have index of 2 and C will
            have index of 1. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.direction = direction
        self.service_chain_id = service_chain_id
        self.service_index = service_index
        VapiStruct.__init__(self)


ServiceChainMapping._set_binding_type(type.StructType(
    'com.vmware.nsx.model.service_chain_mapping', {
        'direction': type.OptionalType(type.StringType()),
        'service_chain_id': type.OptionalType(type.StringType()),
        'service_index': type.OptionalType(type.IntegerType()),
    },
    ServiceChainMapping,
    False,
    None))



class ServiceChainMappingListResult(VapiStruct):
    """
    Service Chain Mapping List

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`ServiceChainMapping` or ``None``
        :param results: List of the Service Chain Mappings. The list has to be homogenous.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


ServiceChainMappingListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.service_chain_mapping_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ServiceChainMapping'))),
    },
    ServiceChainMappingListResult,
    False,
    None))



class ServiceConfig(VapiStruct):
    """
    Service configs are groupings of profiles (i.e switch profiles) and
    configurations applied to resources or collection of resources(NSGroups).

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'applied_to': 'applied_to',
                            'precedence': 'precedence',
                            'profiles': 'profiles',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 applied_to=None,
                 precedence=None,
                 profiles=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  applied_to: :class:`list` of :class:`ResourceReference` or ``None``
        :param applied_to: The list of entities that the configurations should be applied to.
            This can either be a NSGroup or any other entity like
            TransportNode, LogicalPorts etc.
        :type  precedence: :class:`long` or ``None``
        :param precedence: Every ServiceConfig has a priority based upon its precedence value.
            Lower the value of precedence, higher will be its priority. If user
            doesnt specify the precedence, it is generated automatically by
            system. The precedence is generated based upon the type of profile
            used in ServiceConfig. Precedence are auto-generated in decreasing
            order with difference of 100. Automatically generated precedence
            value will be 100 less than the current minimum value of precedence
            of ServiceConfig of a given profile type in system.There cannot be
            duplicate precedence for ServiceConfig of same profile type.
            format: int64
        :type  profiles: :class:`list` of :class:`NSXProfileReference` or ``None``
        :param profiles: These are the NSX Profiles which will be added to service config,
            which will be applied to entities/groups provided to applied_to
            field of service config.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.applied_to = applied_to
        self.precedence = precedence
        self.profiles = profiles
        VapiStruct.__init__(self)


ServiceConfig._set_binding_type(type.StructType(
    'com.vmware.nsx.model.service_config', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'applied_to': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceReference'))),
        'precedence': type.OptionalType(type.IntegerType()),
        'profiles': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NSXProfileReference'))),
    },
    ServiceConfig,
    False,
    None))



class ServiceConfigList(VapiStruct):
    """
    List of Service config objects that needs to be either created or updated
    with the respective profiles and precedence.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'service_configs': 'service_configs',
                            }

    def __init__(self,
                 service_configs=None,
                ):
        """
        :type  service_configs: :class:`list` of :class:`ServiceConfig` or ``None``
        :param service_configs: An Array of ServiceConfig objects containing details of profiles to
            be applied, entities on which these profiles will be applied and
            precedence.
        """
        self.service_configs = service_configs
        VapiStruct.__init__(self)


ServiceConfigList._set_binding_type(type.StructType(
    'com.vmware.nsx.model.service_config_list', {
        'service_configs': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ServiceConfig'))),
    },
    ServiceConfigList,
    False,
    None))



class ServiceConfigListResult(VapiStruct):
    """
    Paged Collection of service configs

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`ServiceConfig` or ``None``
        :param results: service config list results
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


ServiceConfigListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.service_config_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ServiceConfig'))),
    },
    ServiceConfigListResult,
    False,
    None))



class ServiceDefinition(VapiStruct):
    """
    Registering a Service is the first step in the ServiceInsertion mechanism.
    A ServiceDefinition is used to create a service.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    ATTACHMENT_POINT_TIER0_LR = "TIER0_LR"
    """


    """
    ATTACHMENT_POINT_TIER1_LR = "TIER1_LR"
    """


    """
    ATTACHMENT_POINT_SERVICE_PLANE = "SERVICE_PLANE"
    """


    """
    FUNCTIONALITIES_NG_FW = "NG_FW"
    """


    """
    FUNCTIONALITIES_IDS_IPS = "IDS_IPS"
    """


    """
    FUNCTIONALITIES_NET_MON = "NET_MON"
    """


    """
    FUNCTIONALITIES_HCX = "HCX"
    """


    """
    FUNCTIONALITIES_BYOD = "BYOD"
    """


    """
    FUNCTIONALITIES_EPP = "EPP"
    """


    """
    IMPLEMENTATIONS_NORTH_SOUTH = "NORTH_SOUTH"
    """


    """
    IMPLEMENTATIONS_EAST_WEST = "EAST_WEST"
    """


    """
    ON_FAILURE_POLICY_ALLOW = "ALLOW"
    """


    """
    ON_FAILURE_POLICY_BLOCK = "BLOCK"
    """


    """
    TRANSPORTS_L2_BRIDGE = "L2_BRIDGE"
    """


    """
    TRANSPORTS_L3_ROUTED = "L3_ROUTED"
    """


    """
    TRANSPORTS_NSH = "NSH"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'attachment_point': 'attachment_point',
                            'functionalities': 'functionalities',
                            'implementations': 'implementations',
                            'on_failure_policy': 'on_failure_policy',
                            'service_capability': 'service_capability',
                            'service_deployment_spec': 'service_deployment_spec',
                            'service_manager_id': 'service_manager_id',
                            'transports': 'transports',
                            'vendor_id': 'vendor_id',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 attachment_point=None,
                 functionalities=None,
                 implementations=None,
                 on_failure_policy=None,
                 service_capability=None,
                 service_deployment_spec=None,
                 service_manager_id=None,
                 transports=None,
                 vendor_id=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  attachment_point: :class:`list` of :class:`str` or ``None``
        :param attachment_point: Possible values are: 
            
            * :attr:`ServiceDefinition.ATTACHMENT_POINT_TIER0_LR`
            * :attr:`ServiceDefinition.ATTACHMENT_POINT_TIER1_LR`
            * :attr:`ServiceDefinition.ATTACHMENT_POINT_SERVICE_PLANE`
            
            The point at which the service is deployed/attached for redirecting
            the traffic to the the partner appliance. Attachment Point is
            required if Service caters to any functionality other than EPP.
        :type  functionalities: :class:`list` of :class:`str` or ``None``
        :param functionalities: Possible values are: 
            
            * :attr:`ServiceDefinition.FUNCTIONALITIES_NG_FW`
            * :attr:`ServiceDefinition.FUNCTIONALITIES_IDS_IPS`
            * :attr:`ServiceDefinition.FUNCTIONALITIES_NET_MON`
            * :attr:`ServiceDefinition.FUNCTIONALITIES_HCX`
            * :attr:`ServiceDefinition.FUNCTIONALITIES_BYOD`
            * :attr:`ServiceDefinition.FUNCTIONALITIES_EPP`
            
            The capabilities provided by the services. Needs to be one or more
            of the following | NG_FW - Next Generation Firewall | IDS_IPS -
            Intrusion detection System / Intrusion Prevention System | NET_MON
            - Network Monitoring | HCX - Hybrid Cloud Exchange | BYOD - Bring
            Your Own Device | EPP - Endpoint Protection.(Third party AntiVirus
            partners using NXGI should use this functionality for the service)
        :type  implementations: :class:`list` of :class:`str` or ``None``
        :param implementations: Possible values are: 
            
            * :attr:`ServiceDefinition.IMPLEMENTATIONS_NORTH_SOUTH`
            * :attr:`ServiceDefinition.IMPLEMENTATIONS_EAST_WEST`
            
            This indicates the insertion point of the service i.e whether the
            service will be used to protect North-South or East-West traffic in
            the datacenter.
        :type  on_failure_policy: :class:`str` or ``None``
        :param on_failure_policy: Possible values are: 
            
            * :attr:`ServiceDefinition.ON_FAILURE_POLICY_ALLOW`
            * :attr:`ServiceDefinition.ON_FAILURE_POLICY_BLOCK`
            
            Failure policy for the service tells datapath, the action to take
            i.e to Allow or Block traffic during failure scenarios. For
            north-south ServiceInsertion, failure policy in the service
            instance takes precedence. For east-west ServiceInsertion, failure
            policy in the service chain takes precedence. BLOCK is not
            supported for Endpoint protection (EPP) functionality.
        :type  service_capability: :class:`ServiceCapability` or ``None``
        :param service_capability: Service capability.
        :type  service_deployment_spec: :class:`ServiceDeploymentSpec` or ``None``
        :param service_deployment_spec: Service Deployment Specification defines takes in information
            required to deploy and configure a partner appliance/service-vm.
        :type  service_manager_id: :class:`str` or ``None``
        :param service_manager_id: ID of the service manager to which this service is attached with.
            This field is not set during creation of service. This field will
            be set explicitly when Service Manager is created successfully
            using this service.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  transports: :class:`list` of :class:`str` or ``None``
        :param transports: Possible values are: 
            
            * :attr:`ServiceDefinition.TRANSPORTS_L2_BRIDGE`
            * :attr:`ServiceDefinition.TRANSPORTS_L3_ROUTED`
            * :attr:`ServiceDefinition.TRANSPORTS_NSH`
            
            Transport Type of the service, which is the mechanism of
            redirecting the traffic to the the partner appliance. Transport
            type is required if Service caters to any functionality other than
            EPP.
        :type  vendor_id: :class:`str` or ``None``
        :param vendor_id: Id which is unique to a vendor or partner for which the service is
            created.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.attachment_point = attachment_point
        self.functionalities = functionalities
        self.implementations = implementations
        self.on_failure_policy = on_failure_policy
        self.service_capability = service_capability
        self.service_deployment_spec = service_deployment_spec
        self.service_manager_id = service_manager_id
        self.transports = transports
        self.vendor_id = vendor_id
        VapiStruct.__init__(self)


ServiceDefinition._set_binding_type(type.StructType(
    'com.vmware.nsx.model.service_definition', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'attachment_point': type.OptionalType(type.ListType(type.StringType())),
        'functionalities': type.OptionalType(type.ListType(type.StringType())),
        'implementations': type.OptionalType(type.ListType(type.StringType())),
        'on_failure_policy': type.OptionalType(type.StringType()),
        'service_capability': type.OptionalType(type.ReferenceType(__name__, 'ServiceCapability')),
        'service_deployment_spec': type.OptionalType(type.ReferenceType(__name__, 'ServiceDeploymentSpec')),
        'service_manager_id': type.OptionalType(type.StringType()),
        'transports': type.OptionalType(type.ListType(type.StringType())),
        'vendor_id': type.OptionalType(type.StringType()),
    },
    ServiceDefinition,
    False,
    None))



class ServiceDeployment(VapiStruct):
    """
    Used to provide the deployment specification for the service.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    DEPLOYMENT_MODE_STAND_ALONE = "STAND_ALONE"
    """


    """
    DEPLOYMENT_MODE_ACTIVE_STANDBY = "ACTIVE_STANDBY"
    """


    """
    DEPLOYMENT_TYPE_HOSTLOCAL = "HOSTLOCAL"
    """


    """
    DEPLOYMENT_TYPE_CLUSTERED = "CLUSTERED"
    """


    """
    PERIMETER_CLUSTER = "CLUSTER"
    """


    """
    PERIMETER_HOST = "HOST"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'clustered_deployment_count': 'clustered_deployment_count',
                            'deployed_to': 'deployed_to',
                            'deployment_mode': 'deployment_mode',
                            'deployment_spec_name': 'deployment_spec_name',
                            'deployment_type': 'deployment_type',
                            'instance_deployment_template': 'instance_deployment_template',
                            'perimeter': 'perimeter',
                            'service_deployment_config': 'service_deployment_config',
                            'service_id': 'service_id',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 clustered_deployment_count=None,
                 deployed_to=None,
                 deployment_mode=None,
                 deployment_spec_name=None,
                 deployment_type=None,
                 instance_deployment_template=None,
                 perimeter=None,
                 service_deployment_config=None,
                 service_id=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  clustered_deployment_count: :class:`long` or ``None``
        :param clustered_deployment_count: Number of instances in case of clustered deployment. format: int64
        :type  deployed_to: :class:`list` of :class:`ResourceReference` or ``None``
        :param deployed_to: List of resource references where service instance be deployed. Ex.
            Tier 0 Logical Router in case of N-S ServiceInsertion. Service
            Attachment in case of E-W ServiceInsertion.
        :type  deployment_mode: :class:`str` or ``None``
        :param deployment_mode: Possible values are: 
            
            * :attr:`ServiceDeployment.DEPLOYMENT_MODE_STAND_ALONE`
            * :attr:`ServiceDeployment.DEPLOYMENT_MODE_ACTIVE_STANDBY`
            
            Mode of deployment. Currently, only stand alone deployment is
            supported. It is a single VM deployed through this deployment spec.
            In future, HA configurations will be supported here.
        :type  deployment_spec_name: :class:`str` or ``None``
        :param deployment_spec_name: Name of the deployment spec to be used for deployment, which
            specifies the OVF provided by the partner and the form factor.
        :type  deployment_type: :class:`str` or ``None``
        :param deployment_type: Possible values are: 
            
            * :attr:`ServiceDeployment.DEPLOYMENT_TYPE_HOSTLOCAL`
            * :attr:`ServiceDeployment.DEPLOYMENT_TYPE_CLUSTERED`
            
            Specifies whether the service VM should be deployed on each host
            such that it provides partner service locally on the host, or
            whether the service VMs can be deployed as a cluster. If
            deployment_type is CLUSTERED, then the clustered_deployment_count
            should be provided.
        :type  instance_deployment_template: :class:`DeploymentTemplate` or ``None``
        :param instance_deployment_template: The deployment template to be used during the deployment to provide
            customized attributes to the service VM.
        :type  perimeter: :class:`str` or ``None``
        :param perimeter: Possible values are: 
            
            * :attr:`ServiceDeployment.PERIMETER_CLUSTER`
            * :attr:`ServiceDeployment.PERIMETER_HOST`
            
            This indicates the deployment perimeter, such as a VC cluster or a
            host.
        :type  service_deployment_config: :class:`ServiceDeploymentConfig` or ``None``
        :param service_deployment_config: Deployment Config contains the deployment specification, such as
            the storage and network to be used along with the cluster where the
            service VM can be deployed.
        :type  service_id: :class:`str` or ``None``
        :param service_id: The Service to which the service deployment is associated.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.clustered_deployment_count = clustered_deployment_count
        self.deployed_to = deployed_to
        self.deployment_mode = deployment_mode
        self.deployment_spec_name = deployment_spec_name
        self.deployment_type = deployment_type
        self.instance_deployment_template = instance_deployment_template
        self.perimeter = perimeter
        self.service_deployment_config = service_deployment_config
        self.service_id = service_id
        VapiStruct.__init__(self)


ServiceDeployment._set_binding_type(type.StructType(
    'com.vmware.nsx.model.service_deployment', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'clustered_deployment_count': type.OptionalType(type.IntegerType()),
        'deployed_to': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceReference'))),
        'deployment_mode': type.OptionalType(type.StringType()),
        'deployment_spec_name': type.OptionalType(type.StringType()),
        'deployment_type': type.OptionalType(type.StringType()),
        'instance_deployment_template': type.OptionalType(type.ReferenceType(__name__, 'DeploymentTemplate')),
        'perimeter': type.OptionalType(type.StringType()),
        'service_deployment_config': type.OptionalType(type.ReferenceType(__name__, 'ServiceDeploymentConfig')),
        'service_id': type.OptionalType(type.StringType()),
    },
    ServiceDeployment,
    False,
    None))



class ServiceDeploymentConfig(VapiStruct):
    """
    The Deployment Config contains settings that are applied during install
    time.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'compute_collection_id': 'compute_collection_id',
                            'compute_manager_id': 'compute_manager_id',
                            'host_id': 'host_id',
                            'storage_id': 'storage_id',
                            'vm_nic_info': 'vm_nic_info',
                            }

    def __init__(self,
                 compute_collection_id=None,
                 compute_manager_id=None,
                 host_id=None,
                 storage_id=None,
                 vm_nic_info=None,
                ):
        """
        :type  compute_collection_id: :class:`str` or ``None``
        :param compute_collection_id: Resource Pool or cluster Id.
        :type  compute_manager_id: :class:`str` or ``None``
        :param compute_manager_id: Context Id or VCenter Id.
        :type  host_id: :class:`str` or ``None``
        :param host_id: The service VM will be deployed on the specified host in the
            specified server within the cluster if host_id is specified. Note:
            You must ensure that storage and specified networks are accessible
            by this host.
        :type  storage_id: :class:`str` or ``None``
        :param storage_id: Moref of the datastore in VC. If it is to be taken from 'Agent VM
            Settings', then it should be empty.
        :type  vm_nic_info: :class:`VmNicInfo` or ``None``
        :param vm_nic_info: VM NIC information for VMs
        """
        self.compute_collection_id = compute_collection_id
        self.compute_manager_id = compute_manager_id
        self.host_id = host_id
        self.storage_id = storage_id
        self.vm_nic_info = vm_nic_info
        VapiStruct.__init__(self)


ServiceDeploymentConfig._set_binding_type(type.StructType(
    'com.vmware.nsx.model.service_deployment_config', {
        'compute_collection_id': type.OptionalType(type.StringType()),
        'compute_manager_id': type.OptionalType(type.StringType()),
        'host_id': type.OptionalType(type.StringType()),
        'storage_id': type.OptionalType(type.StringType()),
        'vm_nic_info': type.OptionalType(type.ReferenceType(__name__, 'VmNicInfo')),
    },
    ServiceDeploymentConfig,
    False,
    None))



class ServiceDeploymentIssue(VapiStruct):
    """
    Type of issue and detailed description of the issue in case of deployment
    failure.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'issue_description': 'issue_description',
                            'issue_timestamp': 'issue_timestamp',
                            'issue_type': 'issue_type',
                            }

    def __init__(self,
                 issue_description=None,
                 issue_timestamp=None,
                 issue_type=None,
                ):
        """
        :type  issue_description: :class:`str` or ``None``
        :param issue_description: Description of issue encountered while service deployment.
        :type  issue_timestamp: :class:`str` or ``None``
        :param issue_timestamp: Timestamp when issue was issue encountered while service
            deployment.
        :type  issue_type: :class:`str` or ``None``
        :param issue_type: Type of issue encountered while service deployment.
        """
        self.issue_description = issue_description
        self.issue_timestamp = issue_timestamp
        self.issue_type = issue_type
        VapiStruct.__init__(self)


ServiceDeploymentIssue._set_binding_type(type.StructType(
    'com.vmware.nsx.model.service_deployment_issue', {
        'issue_description': type.OptionalType(type.StringType()),
        'issue_timestamp': type.OptionalType(type.StringType()),
        'issue_type': type.OptionalType(type.StringType()),
    },
    ServiceDeploymentIssue,
    False,
    None))



class ServiceDeploymentListResult(VapiStruct):
    """
    Result of List of ServiceDeployments

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`ServiceDeployment` or ``None``
        :param results: Array of existing ServiceDeployments in database
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


ServiceDeploymentListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.service_deployment_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ServiceDeployment'))),
    },
    ServiceDeploymentListResult,
    False,
    None))



class ServiceDeploymentSpec(VapiStruct):
    """
    ServiceDeployment Spec consists of information required to deploy and
    configure the partner appliances. viz. Deployment template, deployment spec
    and NIC metatdata.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'deployment_specs': 'deployment_specs',
                            'deployment_template': 'deployment_template',
                            'nic_metadata_list': 'nic_metadata_list',
                            'svm_version': 'svm_version',
                            }

    def __init__(self,
                 deployment_specs=None,
                 deployment_template=None,
                 nic_metadata_list=None,
                 svm_version=None,
                ):
        """
        :type  deployment_specs: :class:`list` of :class:`SVMDeploymentSpec` or ``None``
        :param deployment_specs: Deployment Specs holds information required to deploy the
            Service-VMs. i.e. OVF url where the partner Service-VM OVF is
            hosted. The host type on which the OVF can be deployed, Form factor
            to name a few.
        :type  deployment_template: :class:`list` of :class:`DeploymentTemplate` or ``None``
        :param deployment_template: Deployment Template holds the attributes specific to partner for
            which the service is created. These attributes are opaque to NSX
            Manager.
        :type  nic_metadata_list: :class:`list` of :class:`NicMetadata` or ``None``
        :param nic_metadata_list: NIC metadata associated with the deployment spec.
        :type  svm_version: :class:`str` or ``None``
        :param svm_version: Partner needs to specify the Service VM version which will get
            deployed.
        """
        self.deployment_specs = deployment_specs
        self.deployment_template = deployment_template
        self.nic_metadata_list = nic_metadata_list
        self.svm_version = svm_version
        VapiStruct.__init__(self)


ServiceDeploymentSpec._set_binding_type(type.StructType(
    'com.vmware.nsx.model.service_deployment_spec', {
        'deployment_specs': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'SVMDeploymentSpec'))),
        'deployment_template': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'DeploymentTemplate'))),
        'nic_metadata_list': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NicMetadata'))),
        'svm_version': type.OptionalType(type.StringType()),
    },
    ServiceDeploymentSpec,
    False,
    None))



class ServiceDeploymentStatus(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    DEPLOYMENT_STATUS_UPGRADE_IN_PROGRESS = "UPGRADE_IN_PROGRESS"
    """


    """
    DEPLOYMENT_STATUS_UPGRADE_FAILED = "UPGRADE_FAILED"
    """


    """
    DEPLOYMENT_STATUS_DEPLOYMENT_QUEUED = "DEPLOYMENT_QUEUED"
    """


    """
    DEPLOYMENT_STATUS_DEPLOYMENT_IN_PROGRESS = "DEPLOYMENT_IN_PROGRESS"
    """


    """
    DEPLOYMENT_STATUS_DEPLOYMENT_FAILED = "DEPLOYMENT_FAILED"
    """


    """
    DEPLOYMENT_STATUS_DEPLOYMENT_SUCCESSFUL = "DEPLOYMENT_SUCCESSFUL"
    """


    """
    DEPLOYMENT_STATUS_UNDEPLOYMENT_QUEUED = "UNDEPLOYMENT_QUEUED"
    """


    """
    DEPLOYMENT_STATUS_UNDEPLOYMENT_IN_PROGRESS = "UNDEPLOYMENT_IN_PROGRESS"
    """


    """
    DEPLOYMENT_STATUS_UNDEPLOYMENT_FAILED = "UNDEPLOYMENT_FAILED"
    """


    """
    DEPLOYMENT_STATUS_UNDEPLOYMENT_SUCCESSFUL = "UNDEPLOYMENT_SUCCESSFUL"
    """


    """
    DEPLOYMENT_STATUS_UPGRADE_QUEUED = "UPGRADE_QUEUED"
    """


    """



    _canonical_to_pep_names = {
                            'deployment_issues': 'deployment_issues',
                            'deployment_status': 'deployment_status',
                            'last_update_timestamp': 'last_update_timestamp',
                            'service_deployment_id': 'service_deployment_id',
                            'sva_current_version': 'sva_current_version',
                            'sva_max_available_version': 'sva_max_available_version',
                            }

    def __init__(self,
                 deployment_issues=None,
                 deployment_status=None,
                 last_update_timestamp=None,
                 service_deployment_id=None,
                 sva_current_version=None,
                 sva_max_available_version=None,
                ):
        """
        :type  deployment_issues: :class:`list` of :class:`ServiceDeploymentIssue` or ``None``
        :param deployment_issues: List of issue and detailed description of the issue in case of
            deployment failure.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  deployment_status: :class:`str` or ``None``
        :param deployment_status: Possible values are: 
            
            *
              :attr:`ServiceDeploymentStatus.DEPLOYMENT_STATUS_UPGRADE_IN_PROGRESS`
            * :attr:`ServiceDeploymentStatus.DEPLOYMENT_STATUS_UPGRADE_FAILED`
            *
              :attr:`ServiceDeploymentStatus.DEPLOYMENT_STATUS_DEPLOYMENT_QUEUED`
            *
              :attr:`ServiceDeploymentStatus.DEPLOYMENT_STATUS_DEPLOYMENT_IN_PROGRESS`
            *
              :attr:`ServiceDeploymentStatus.DEPLOYMENT_STATUS_DEPLOYMENT_FAILED`
            *
              :attr:`ServiceDeploymentStatus.DEPLOYMENT_STATUS_DEPLOYMENT_SUCCESSFUL`
            *
              :attr:`ServiceDeploymentStatus.DEPLOYMENT_STATUS_UNDEPLOYMENT_QUEUED`
            *
              :attr:`ServiceDeploymentStatus.DEPLOYMENT_STATUS_UNDEPLOYMENT_IN_PROGRESS`
            *
              :attr:`ServiceDeploymentStatus.DEPLOYMENT_STATUS_UNDEPLOYMENT_FAILED`
            *
              :attr:`ServiceDeploymentStatus.DEPLOYMENT_STATUS_UNDEPLOYMENT_SUCCESSFUL`
            * :attr:`ServiceDeploymentStatus.DEPLOYMENT_STATUS_UPGRADE_QUEUED`
            
            Deployment status of NXGI Partner Service-VM on a compute
            collection. It shows the latest status during the process of
            deployment, redeploy, upgrade, and un-deployment on a compute
            collection such as VC cluster.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_update_timestamp: :class:`long` or ``None``
        :param last_update_timestamp: Timestamp when the data was last updated; unset if data source has
            never updated the data. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  service_deployment_id: :class:`str` or ``None``
        :param service_deployment_id: Id of service deployment.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sva_current_version: :class:`str` or ``None``
        :param sva_current_version: Currently deployed Service Virtual Appliance version.
        :type  sva_max_available_version: :class:`str` or ``None``
        :param sva_max_available_version: Max available SVA version for upgrade
        """
        self.deployment_issues = deployment_issues
        self.deployment_status = deployment_status
        self.last_update_timestamp = last_update_timestamp
        self.service_deployment_id = service_deployment_id
        self.sva_current_version = sva_current_version
        self.sva_max_available_version = sva_max_available_version
        VapiStruct.__init__(self)


ServiceDeploymentStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.service_deployment_status', {
        'deployment_issues': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ServiceDeploymentIssue'))),
        'deployment_status': type.OptionalType(type.StringType()),
        'last_update_timestamp': type.OptionalType(type.IntegerType()),
        'service_deployment_id': type.OptionalType(type.StringType()),
        'sva_current_version': type.OptionalType(type.StringType()),
        'sva_max_available_version': type.OptionalType(type.StringType()),
    },
    ServiceDeploymentStatus,
    False,
    None))



class ServiceEndpoint(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'certificate': 'certificate',
                            'certificate_sha256_thumbprint': 'certificate_sha256_thumbprint',
                            'entities_hosted': 'entities_hosted',
                            'fqdn': 'fqdn',
                            'ip_address': 'ip_address',
                            'port': 'port',
                            'service_endpoint_uuid': 'service_endpoint_uuid',
                            }

    def __init__(self,
                 certificate=None,
                 certificate_sha256_thumbprint=None,
                 entities_hosted=None,
                 fqdn=None,
                 ip_address=None,
                 port=None,
                 service_endpoint_uuid=None,
                ):
        """
        :type  certificate: :class:`str` or ``None``
        :param certificate: Certificate or certificate chain
        :type  certificate_sha256_thumbprint: :class:`str` or ``None``
        :param certificate_sha256_thumbprint: 
        :type  entities_hosted: :class:`list` of :class:`HostedEntityInfo` or ``None``
        :param entities_hosted: List of entities hosted on accessible through the service endpoint
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  fqdn: :class:`str` or ``None``
        :param fqdn: 
        :type  ip_address: :class:`str` or ``None``
        :param ip_address: IPv4 or IPv6 address format: ip
        :type  port: :class:`long` or ``None``
        :param port: 
        :type  service_endpoint_uuid: :class:`str` or ``None``
        :param service_endpoint_uuid: Unique identifier of this service endpoint
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.certificate = certificate
        self.certificate_sha256_thumbprint = certificate_sha256_thumbprint
        self.entities_hosted = entities_hosted
        self.fqdn = fqdn
        self.ip_address = ip_address
        self.port = port
        self.service_endpoint_uuid = service_endpoint_uuid
        VapiStruct.__init__(self)


ServiceEndpoint._set_binding_type(type.StructType(
    'com.vmware.nsx.model.service_endpoint', {
        'certificate': type.OptionalType(type.StringType()),
        'certificate_sha256_thumbprint': type.OptionalType(type.StringType()),
        'entities_hosted': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'HostedEntityInfo'))),
        'fqdn': type.OptionalType(type.StringType()),
        'ip_address': type.OptionalType(type.StringType()),
        'port': type.OptionalType(type.IntegerType()),
        'service_endpoint_uuid': type.OptionalType(type.StringType()),
    },
    ServiceEndpoint,
    False,
    None))



class ServiceInsertionRule(VapiStruct):
    """
    ServiceInsertion Rule.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    ACTION_ALLOW = "ALLOW"
    """


    """
    ACTION_DROP = "DROP"
    """


    """
    ACTION_REJECT = "REJECT"
    """


    """
    ACTION_REDIRECT = "REDIRECT"
    """


    """
    ACTION_DO_NOT_REDIRECT = "DO_NOT_REDIRECT"
    """


    """
    ACTION_DETECT = "DETECT"
    """


    """
    DIRECTION_IN = "IN"
    """


    """
    DIRECTION_OUT = "OUT"
    """


    """
    DIRECTION_IN_OUT = "IN_OUT"
    """


    """
    IP_PROTOCOL_IPV4 = "IPV4"
    """


    """
    IP_PROTOCOL_IPV6 = "IPV6"
    """


    """
    IP_PROTOCOL_IPV4_IPV6 = "IPV4_IPV6"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_owner': 'owner',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'action': 'action',
                            'applied_tos': 'applied_tos',
                            'destinations': 'destinations',
                            'destinations_excluded': 'destinations_excluded',
                            'direction': 'direction',
                            'disabled': 'disabled',
                            'ip_protocol': 'ip_protocol',
                            'is_default': 'is_default',
                            'logged': 'logged',
                            'notes': 'notes',
                            'priority': 'priority',
                            'rule_tag': 'rule_tag',
                            'sources': 'sources',
                            'sources_excluded': 'sources_excluded',
                            'redirect_tos': 'redirect_tos',
                            'section_id': 'section_id',
                            'services': 'services',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 owner=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 action=None,
                 applied_tos=None,
                 destinations=None,
                 destinations_excluded=None,
                 direction=None,
                 disabled=None,
                 ip_protocol=None,
                 is_default=None,
                 logged=None,
                 notes=None,
                 priority=None,
                 rule_tag=None,
                 sources=None,
                 sources_excluded=None,
                 redirect_tos=None,
                 section_id=None,
                 services=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  owner: :class:`OwnerResourceLink` or ``None``
        :param owner: Owner of this resource
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Identifier of the resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  action: :class:`str` or ``None``
        :param action: Possible values are: 
            
            * :attr:`ServiceInsertionRule.ACTION_ALLOW`
            * :attr:`ServiceInsertionRule.ACTION_DROP`
            * :attr:`ServiceInsertionRule.ACTION_REJECT`
            * :attr:`ServiceInsertionRule.ACTION_REDIRECT`
            * :attr:`ServiceInsertionRule.ACTION_DO_NOT_REDIRECT`
            * :attr:`ServiceInsertionRule.ACTION_DETECT`
            
            Action enforced on the packets which matches the distributed
            service rule. Currently DS Layer supports below actions. ALLOW -
            Forward any packet when a rule with this action gets a match (Used
            by Firewall). DROP - Drop any packet when a rule with this action
            gets a match. Packets won't go further(Used by Firewall). REJECT -
            Terminate TCP connection by sending TCP reset for a packet when a
            rule with this action gets a match (Used by Firewall). REDIRECT -
            Redirect any packet to a partner appliance when a rule with this
            action gets a match (Used by Service Insertion). DO_NOT_REDIRECT -
            Do not redirect any packet to a partner appliance when a rule with
            this action gets a match (Used by Service Insertion). DETECT -
            Detect IDS Signatures.
        :type  applied_tos: :class:`list` of :class:`ResourceReference` or ``None``
        :param applied_tos: List of object where rule will be enforced. The section level field
            overrides this one. Null will be treated as any.
        :type  destinations: :class:`list` of :class:`ResourceReference` or ``None``
        :param destinations: List of the destinations. Null will be treated as any.
        :type  destinations_excluded: :class:`bool` or ``None``
        :param destinations_excluded: Negation of the destination.
        :type  direction: :class:`str` or ``None``
        :param direction: Possible values are: 
            
            * :attr:`ServiceInsertionRule.DIRECTION_IN`
            * :attr:`ServiceInsertionRule.DIRECTION_OUT`
            * :attr:`ServiceInsertionRule.DIRECTION_IN_OUT`
            
            Rule direction in case of stateless distributed service rules. This
            will only considered if section level parameter is set to
            stateless. Default to IN_OUT if not specified.
        :type  disabled: :class:`bool` or ``None``
        :param disabled: Flag to disable rule. Disabled will only be persisted but never
            provisioned/realized.
        :type  ip_protocol: :class:`str` or ``None``
        :param ip_protocol: Possible values are: 
            
            * :attr:`ServiceInsertionRule.IP_PROTOCOL_IPV4`
            * :attr:`ServiceInsertionRule.IP_PROTOCOL_IPV6`
            * :attr:`ServiceInsertionRule.IP_PROTOCOL_IPV4_IPV6`
            
             Type of IP packet that should be matched while enforcing the rule.
        :type  is_default: :class:`bool` or ``None``
        :param is_default: Flag to indicate whether rule is default.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  logged: :class:`bool` or ``None``
        :param logged: Flag to enable packet logging. Default is disabled.
        :type  notes: :class:`str` or ``None``
        :param notes: User notes specific to the rule.
        :type  priority: :class:`long` or ``None``
        :param priority: Priority of the rule. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  rule_tag: :class:`str` or ``None``
        :param rule_tag: User level field which will be printed in CLI and packet logs.
        :type  sources: :class:`list` of :class:`ResourceReference` or ``None``
        :param sources: List of sources. Null will be treated as any.
        :type  sources_excluded: :class:`bool` or ``None``
        :param sources_excluded: Negation of the source.
        :type  redirect_tos: :class:`list` of :class:`ResourceReference` or ``None``
        :param redirect_tos: A rule can be redirected to ServiceInstance, InstanceEndpoint for
            North/South Traffic. A rule can be redirected to ServiceChain for
            East/West Traffic. For REDIRECT action, redirect_tos is mandatory.
            For DO_NOT_REDIRECT action, redirect_tos is optional.
        :type  section_id: :class:`str` or ``None``
        :param section_id: ID of the section to which this rule belongs.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  services: :class:`list` of :class:`ServiceInsertionService` or ``None``
        :param services: List of the services. Null will be treated as any.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.owner = owner
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.action = action
        self.applied_tos = applied_tos
        self.destinations = destinations
        self.destinations_excluded = destinations_excluded
        self.direction = direction
        self.disabled = disabled
        self.ip_protocol = ip_protocol
        self.is_default = is_default
        self.logged = logged
        self.notes = notes
        self.priority = priority
        self.rule_tag = rule_tag
        self.sources = sources
        self.sources_excluded = sources_excluded
        self.redirect_tos = redirect_tos
        self.section_id = section_id
        self.services = services
        VapiStruct.__init__(self)


ServiceInsertionRule._set_binding_type(type.StructType(
    'com.vmware.nsx.model.service_insertion_rule', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_owner': type.OptionalType(type.ReferenceType(__name__, 'OwnerResourceLink')),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'action': type.OptionalType(type.StringType()),
        'applied_tos': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceReference'))),
        'destinations': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceReference'))),
        'destinations_excluded': type.OptionalType(type.BooleanType()),
        'direction': type.OptionalType(type.StringType()),
        'disabled': type.OptionalType(type.BooleanType()),
        'ip_protocol': type.OptionalType(type.StringType()),
        'is_default': type.OptionalType(type.BooleanType()),
        'logged': type.OptionalType(type.BooleanType()),
        'notes': type.OptionalType(type.StringType()),
        'priority': type.OptionalType(type.IntegerType()),
        'rule_tag': type.OptionalType(type.StringType()),
        'sources': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceReference'))),
        'sources_excluded': type.OptionalType(type.BooleanType()),
        'redirect_tos': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceReference'))),
        'section_id': type.OptionalType(type.StringType()),
        'services': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ServiceInsertionService'))),
    },
    ServiceInsertionRule,
    False,
    None))



class ServiceInsertionRuleList(VapiStruct):
    """
    List of ServiceInsertion Rules.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'rules': 'rules',
                            }

    def __init__(self,
                 rules=None,
                ):
        """
        :type  rules: :class:`list` of :class:`ServiceInsertionRule` or ``None``
        :param rules: List of ServiceInsertion rules in the section. Only homogeneous
            rules are supported.
        """
        self.rules = rules
        VapiStruct.__init__(self)


ServiceInsertionRuleList._set_binding_type(type.StructType(
    'com.vmware.nsx.model.service_insertion_rule_list', {
        'rules': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ServiceInsertionRule'))),
    },
    ServiceInsertionRuleList,
    False,
    None))



class ServiceInsertionRuleListResult(VapiStruct):
    """
    List of ServiceInsertion Rules.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`ServiceInsertionRule` or ``None``
        :param results: ServiceInsertion rule list result with pagination support.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


ServiceInsertionRuleListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.service_insertion_rule_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ServiceInsertionRule'))),
    },
    ServiceInsertionRuleListResult,
    False,
    None))



class ServiceInsertionSection(VapiStruct):
    """
    A ServiceInsertion section composed of ServiceInsertion Rules.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    SECTION_TYPE_LAYER2 = "LAYER2"
    """


    """
    SECTION_TYPE_LAYER3 = "LAYER3"
    """


    """
    SECTION_TYPE_L3REDIRECT = "L3REDIRECT"
    """


    """
    SECTION_TYPE_IDS = "IDS"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'applied_tos': 'applied_tos',
                            'is_default': 'is_default',
                            'rule_count': 'rule_count',
                            'section_type': 'section_type',
                            'stateful': 'stateful',
                            'tcp_strict': 'tcp_strict',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 applied_tos=None,
                 is_default=None,
                 rule_count=None,
                 section_type=None,
                 stateful=None,
                 tcp_strict=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  applied_tos: :class:`list` of :class:`ResourceReference` or ``None``
        :param applied_tos: List of objects where the rules in this section will be enforced.
            This will take precedence over rule level appliedTo.
        :type  is_default: :class:`bool` or ``None``
        :param is_default: It is a boolean flag which reflects whether a distributed service
            section is default section or not. Each Layer 3 and Layer 2 section
            will have at least and at most one default section.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  rule_count: :class:`long` or ``None``
        :param rule_count: Number of rules in this section. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  section_type: :class:`str` or ``None``
        :param section_type: Possible values are: 
            
            * :attr:`ServiceInsertionSection.SECTION_TYPE_LAYER2`
            * :attr:`ServiceInsertionSection.SECTION_TYPE_LAYER3`
            * :attr:`ServiceInsertionSection.SECTION_TYPE_L3REDIRECT`
            * :attr:`ServiceInsertionSection.SECTION_TYPE_IDS`
            
            Type of the rules which a section can contain. Only homogeneous
            sections are supported.
        :type  stateful: :class:`bool` or ``None``
        :param stateful: Stateful or Stateless nature of distributed service section is
            enforced on all rules inside the section. Layer3 sections can be
            stateful or stateless. Layer2 sections can only be stateless.
        :type  tcp_strict: :class:`bool` or ``None``
        :param tcp_strict: Ensures that a three way TCP handshake is done before the data
            packets are sent if the value is set to be true. tcp_strict=true is
            supported only for stateful sections.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.applied_tos = applied_tos
        self.is_default = is_default
        self.rule_count = rule_count
        self.section_type = section_type
        self.stateful = stateful
        self.tcp_strict = tcp_strict
        VapiStruct.__init__(self)


ServiceInsertionSection._set_binding_type(type.StructType(
    'com.vmware.nsx.model.service_insertion_section', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'applied_tos': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceReference'))),
        'is_default': type.OptionalType(type.BooleanType()),
        'rule_count': type.OptionalType(type.IntegerType()),
        'section_type': type.OptionalType(type.StringType()),
        'stateful': type.OptionalType(type.BooleanType()),
        'tcp_strict': type.OptionalType(type.BooleanType()),
    },
    ServiceInsertionSection,
    False,
    None))



class ServiceInsertionSectionListResult(VapiStruct):
    """
    List of ServiceInsertion Sections.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`ServiceInsertionSection` or ``None``
        :param results: List of the ServiceInsertion sections. The list has to be
            homogeneous.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


ServiceInsertionSectionListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.service_insertion_section_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ServiceInsertionSection'))),
    },
    ServiceInsertionSectionListResult,
    False,
    None))



class ServiceInsertionSectionRuleList(VapiStruct):
    """
    List of ServiceInsertion Rules.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    SECTION_TYPE_LAYER2 = "LAYER2"
    """


    """
    SECTION_TYPE_LAYER3 = "LAYER3"
    """


    """
    SECTION_TYPE_L3REDIRECT = "L3REDIRECT"
    """


    """
    SECTION_TYPE_IDS = "IDS"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'applied_tos': 'applied_tos',
                            'is_default': 'is_default',
                            'rule_count': 'rule_count',
                            'section_type': 'section_type',
                            'stateful': 'stateful',
                            'tcp_strict': 'tcp_strict',
                            'rules': 'rules',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 applied_tos=None,
                 is_default=None,
                 rule_count=None,
                 section_type=None,
                 stateful=None,
                 tcp_strict=None,
                 rules=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  applied_tos: :class:`list` of :class:`ResourceReference` or ``None``
        :param applied_tos: List of objects where the rules in this section will be enforced.
            This will take precedence over rule level appliedTo.
        :type  is_default: :class:`bool` or ``None``
        :param is_default: It is a boolean flag which reflects whether a distributed service
            section is default section or not. Each Layer 3 and Layer 2 section
            will have at least and at most one default section.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  rule_count: :class:`long` or ``None``
        :param rule_count: Number of rules in this section. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  section_type: :class:`str` or ``None``
        :param section_type: Possible values are: 
            
            * :attr:`ServiceInsertionSectionRuleList.SECTION_TYPE_LAYER2`
            * :attr:`ServiceInsertionSectionRuleList.SECTION_TYPE_LAYER3`
            * :attr:`ServiceInsertionSectionRuleList.SECTION_TYPE_L3REDIRECT`
            * :attr:`ServiceInsertionSectionRuleList.SECTION_TYPE_IDS`
            
            Type of the rules which a section can contain. Only homogeneous
            sections are supported.
        :type  stateful: :class:`bool` or ``None``
        :param stateful: Stateful or Stateless nature of distributed service section is
            enforced on all rules inside the section. Layer3 sections can be
            stateful or stateless. Layer2 sections can only be stateless.
        :type  tcp_strict: :class:`bool` or ``None``
        :param tcp_strict: Ensures that a three way TCP handshake is done before the data
            packets are sent if the value is set to be true. tcp_strict=true is
            supported only for stateful sections.
        :type  rules: :class:`list` of :class:`ServiceInsertionRule` or ``None``
        :param rules: List of Service Insertion rules in the section. Only homogeneous
            rules are supported.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.applied_tos = applied_tos
        self.is_default = is_default
        self.rule_count = rule_count
        self.section_type = section_type
        self.stateful = stateful
        self.tcp_strict = tcp_strict
        self.rules = rules
        VapiStruct.__init__(self)


ServiceInsertionSectionRuleList._set_binding_type(type.StructType(
    'com.vmware.nsx.model.service_insertion_section_rule_list', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'applied_tos': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceReference'))),
        'is_default': type.OptionalType(type.BooleanType()),
        'rule_count': type.OptionalType(type.IntegerType()),
        'section_type': type.OptionalType(type.StringType()),
        'stateful': type.OptionalType(type.BooleanType()),
        'tcp_strict': type.OptionalType(type.BooleanType()),
        'rules': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ServiceInsertionRule'))),
    },
    ServiceInsertionSectionRuleList,
    False,
    None))



class ServiceInsertionService(VapiStruct):
    """
    Protocol on which a particular ServiceInsertion Rule should apply to.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'is_valid': 'is_valid',
                            'target_display_name': 'target_display_name',
                            'target_id': 'target_id',
                            'target_type': 'target_type',
                            'service': 'service',
                            }

    def __init__(self,
                 is_valid=None,
                 target_display_name=None,
                 target_id=None,
                 target_type=None,
                 service=None,
                ):
        """
        :type  is_valid: :class:`bool` or ``None``
        :param is_valid: Will be set to false if the referenced NSX resource has been
            deleted.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  target_display_name: :class:`str` or ``None``
        :param target_display_name: Display name of the NSX resource.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  target_id: :class:`str` or ``None``
        :param target_id: Identifier of the NSX resource.
        :type  target_type: :class:`str` or ``None``
        :param target_type: Type of the NSX resource.
        :type  service: :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param service: Distributed Service API accepts raw protocol and ports as part of
            NS service element in Distributed Service Rule that describes
            traffic corresponding to an NSService.
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`NSServiceElement`. When methods return a value of this
            class as a return value, the attribute will contain all the
            attributes defined in :class:`NSServiceElement`.
        """
        self.is_valid = is_valid
        self.target_display_name = target_display_name
        self.target_id = target_id
        self.target_type = target_type
        self.service = service
        VapiStruct.__init__(self)


ServiceInsertionService._set_binding_type(type.StructType(
    'com.vmware.nsx.model.service_insertion_service', {
        'is_valid': type.OptionalType(type.BooleanType()),
        'target_display_name': type.OptionalType(type.StringType()),
        'target_id': type.OptionalType(type.StringType()),
        'target_type': type.OptionalType(type.StringType()),
        'service': type.OptionalType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'NSServiceElement')])),
    },
    ServiceInsertionService,
    False,
    None))



class ServiceInsertionServiceListResult(VapiStruct):
    """
    Service List

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`ServiceDefinition` or ``None``
        :param results: List of the Service-Insertion Services. The list has to be
            homogenous.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


ServiceInsertionServiceListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.service_insertion_service_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ServiceDefinition'))),
    },
    ServiceInsertionServiceListResult,
    False,
    None))



class ServiceInsertionServiceProfile(VapiStruct):
    """
    Service profile represents a specialization of vendor template.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "ServiceInsertionServiceProfile"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    REDIRECTION_ACTION_PUNT = "PUNT"
    """


    """
    REDIRECTION_ACTION_COPY = "COPY"
    """


    """



    _canonical_to_pep_names = {
                            'attributes': 'attributes',
                            'redirection_action': 'redirection_action',
                            'service_id': 'service_id',
                            'vendor_template_id': 'vendor_template_id',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            }

    def __init__(self,
                 attributes=None,
                 redirection_action=None,
                 service_id=None,
                 vendor_template_id=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='ServiceInsertionServiceProfile',
                 tags=None,
                ):
        """
        :type  attributes: :class:`list` of :class:`Attribute` or ``None``
        :param attributes: List of attributes specific to a partner for which the service is
            created. These attributes are passed on to the partner appliance
            and are opaque to the NSX Manager. If a vendor template exposes
            configurables, then the values are specified here.
        :type  redirection_action: :class:`str` or ``None``
        :param redirection_action: Possible values are: 
            
            * :attr:`ServiceInsertionServiceProfile.REDIRECTION_ACTION_PUNT`
            * :attr:`ServiceInsertionServiceProfile.REDIRECTION_ACTION_COPY`
            
            The redirection action represents if the packet is exclusively
            redirected to the service, or if a copy is forwarded to the
            service. The service insertion profile inherits the redirection
            action if already specified at the vendor template. However the
            service profile cannot overide the action specified at the vendor
            template.
        :type  service_id: :class:`str` or ``None``
        :param service_id: The service to which the service profile belongs.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  vendor_template_id: :class:`str` or ``None``
        :param vendor_template_id: Id of the vendor template to be used by the servive profile.
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Service Profile type, for example 'GiServiceProfile',
            'ServiceInsertionServiceProfile'
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        """
        self.attributes = attributes
        self.redirection_action = redirection_action
        self.service_id = service_id
        self.vendor_template_id = vendor_template_id
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

ServiceInsertionServiceProfile._set_binding_type(type.StructType(
    'com.vmware.nsx.model.service_insertion_service_profile', {
        'attributes': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Attribute'))),
        'redirection_action': type.OptionalType(type.StringType()),
        'service_id': type.OptionalType(type.StringType()),
        'vendor_template_id': type.OptionalType(type.StringType()),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
    },
    ServiceInsertionServiceProfile,
    False,
    None))



class ServiceInsertionStatus(VapiStruct):
    """
    It represents global status of Service Insertion for a particular context
    type. It shows whether a service insertion is enabled or not for a type.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    CONTEXT_EAST_WEST = "east_west"
    """


    """
    CONTEXT_NORTH_SOUTH = "north_south"
    """


    """
    GLOBAL_STATUS_DISABLED = "DISABLED"
    """


    """
    GLOBAL_STATUS_ENABLED = "ENABLED"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'context': 'context',
                            'global_status': 'global_status',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 context=None,
                 global_status=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  context: :class:`str` or ``None``
        :param context: Possible values are: 
            
            * :attr:`ServiceInsertionStatus.CONTEXT_EAST_WEST`
            * :attr:`ServiceInsertionStatus.CONTEXT_NORTH_SOUTH`
            
             Type of service insertion contexts.
        :type  global_status: :class:`str` or ``None``
        :param global_status: Possible values are: 
            
            * :attr:`ServiceInsertionStatus.GLOBAL_STATUS_DISABLED`
            * :attr:`ServiceInsertionStatus.GLOBAL_STATUS_ENABLED`
            
            service insertion status for a context type (e.g. east_west
            traffic).
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.context = context
        self.global_status = global_status
        VapiStruct.__init__(self)


ServiceInsertionStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.service_insertion_status', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'context': type.OptionalType(type.StringType()),
        'global_status': type.OptionalType(type.StringType()),
    },
    ServiceInsertionStatus,
    False,
    None))



class ServiceInsertionStatusListResult(VapiStruct):
    """
    List of service insertion statuses for a context or all context

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`ServiceInsertionStatus` or ``None``
        :param results: 
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


ServiceInsertionStatusListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.service_insertion_status_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ServiceInsertionStatus'))),
    },
    ServiceInsertionStatusListResult,
    False,
    None))



class ServiceInstance(VapiStruct):
    """
    The deployment of a registered service. Service instance is instantiation
    of service. It is the most used type of instance. It is a default instance
    to be used when NSX handles lifecycle of appliance. Deployment and
    appliance related all the information is necessary.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "ServiceInstance"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    ATTACHMENT_POINT_TIER0_LR = "TIER0_LR"
    """


    """
    ATTACHMENT_POINT_TIER1_LR = "TIER1_LR"
    """


    """
    ATTACHMENT_POINT_SERVICE_PLANE = "SERVICE_PLANE"
    """


    """
    ATTACHMENT_POINT_HOST = "HOST"
    """


    """
    DEPLOYMENT_MODE_STAND_ALONE = "STAND_ALONE"
    """


    """
    DEPLOYMENT_MODE_ACTIVE_STANDBY = "ACTIVE_STANDBY"
    """


    """
    IMPLEMENTATION_TYPE_NORTH_SOUTH = "NORTH_SOUTH"
    """


    """
    IMPLEMENTATION_TYPE_EAST_WEST = "EAST_WEST"
    """


    """



    _canonical_to_pep_names = {
                            'attachment_point': 'attachment_point',
                            'deployed_to': 'deployed_to',
                            'deployment_mode': 'deployment_mode',
                            'deployment_spec_name': 'deployment_spec_name',
                            'implementation_type': 'implementation_type',
                            'instance_deployment_config': 'instance_deployment_config',
                            'instance_deployment_template': 'instance_deployment_template',
                            'service_deployment_id': 'service_deployment_id',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'on_failure_policy': 'on_failure_policy',
                            'service_id': 'service_id',
                            'transport_type': 'transport_type',
                            }

    def __init__(self,
                 attachment_point=None,
                 deployed_to=None,
                 deployment_mode=None,
                 deployment_spec_name=None,
                 implementation_type=None,
                 instance_deployment_config=None,
                 instance_deployment_template=None,
                 service_deployment_id=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='ServiceInstance',
                 tags=None,
                 on_failure_policy=None,
                 service_id=None,
                 transport_type=None,
                ):
        """
        :type  attachment_point: :class:`str` or ``None``
        :param attachment_point: Possible values are: 
            
            * :attr:`ServiceInstance.ATTACHMENT_POINT_TIER0_LR`
            * :attr:`ServiceInstance.ATTACHMENT_POINT_TIER1_LR`
            * :attr:`ServiceInstance.ATTACHMENT_POINT_SERVICE_PLANE`
            * :attr:`ServiceInstance.ATTACHMENT_POINT_HOST`
            
            Attachment point to be used by this service instance for deploying
            the Service-VM.
        :type  deployed_to: :class:`list` of :class:`ResourceReference` or ``None``
        :param deployed_to: List of resource references where service instance be deployed. Ex.
            Tier 0 Logical Router in case of N-S ServiceInsertion.
        :type  deployment_mode: :class:`str` or ``None``
        :param deployment_mode: Possible values are: 
            
            * :attr:`ServiceInstance.DEPLOYMENT_MODE_STAND_ALONE`
            * :attr:`ServiceInstance.DEPLOYMENT_MODE_ACTIVE_STANDBY`
            
            Deployment mode specifies where the partner appliance will be
            deployed in HA or non-HA i.e standalone mode.
        :type  deployment_spec_name: :class:`str` or ``None``
        :param deployment_spec_name: Name of the deployment spec to be used by this service instance.
        :type  implementation_type: :class:`str` or ``None``
        :param implementation_type: Possible values are: 
            
            * :attr:`ServiceInstance.IMPLEMENTATION_TYPE_NORTH_SOUTH`
            * :attr:`ServiceInstance.IMPLEMENTATION_TYPE_EAST_WEST`
            
            Implementation to be used by this service instance for deploying
            the Service-VM.
        :type  instance_deployment_config: :class:`InstanceDeploymentConfig` or ``None``
        :param instance_deployment_config: Instance Deployment Config contains the information to be injected
            during Service-VM deployment. This field is optional if the service
            only caters to functionality EPP(Endpoint Protection).
        :type  instance_deployment_template: :class:`DeploymentTemplate` or ``None``
        :param instance_deployment_template: The deployment template to be used by this service instance. The
            attribute values specific to this instance can be added.
        :type  service_deployment_id: :class:`str` or ``None``
        :param service_deployment_id: Id of the Service Deployment using which the instances were
            deployed. Its available only for instances that were deployed using
            service deployment API.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`BaseServiceInstance.RESOURCE_TYPE_SERVICEINSTANCE`
            * :attr:`BaseServiceInstance.RESOURCE_TYPE_BYODSERVICEINSTANCE`
            * :attr:`BaseServiceInstance.RESOURCE_TYPE_VIRTUALSERVICEINSTANCE`
            
            ServiceInstance is used when NSX handles the lifecyle of appliance.
            Deployment and appliance related all the information is necessary.
            ByodServiceInstance is a custom instance to be used when NSX is not
            handling the lifecycles of appliance/s. User will manage their own
            appliance (BYOD) to connect with NSX. VirtualServiceInstance is a a
            custom instance to be used when NSX is not handling the lifecycle
            of an appliance and when the user is not bringing their own
            appliance.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  on_failure_policy: :class:`str` or ``None``
        :param on_failure_policy: Possible values are: 
            
            * :attr:`BaseServiceInstance.ON_FAILURE_POLICY_ALLOW`
            * :attr:`BaseServiceInstance.ON_FAILURE_POLICY_BLOCK`
            
            Failure policy of the service instance - if it has to be different
            from the service. By default the service instance inherits the
            FailurePolicy of the service it belongs to.
        :type  service_id: :class:`str` or ``None``
        :param service_id: The Service to which the service instance is associated.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  transport_type: :class:`str` or ``None``
        :param transport_type: Possible values are: 
            
            * :attr:`BaseServiceInstance.TRANSPORT_TYPE_L2_BRIDGE`
            * :attr:`BaseServiceInstance.TRANSPORT_TYPE_L3_ROUTED`
            * :attr:`BaseServiceInstance.TRANSPORT_TYPE_NSH`
            * :attr:`BaseServiceInstance.TRANSPORT_TYPE_NA`
            
            Transport to be used by this service instance for deploying the
            Service-VM. This field is to be set Not Applicable(NA) if the
            service only caters to functionality EPP(Endpoint Protection).
        """
        self.attachment_point = attachment_point
        self.deployed_to = deployed_to
        self.deployment_mode = deployment_mode
        self.deployment_spec_name = deployment_spec_name
        self.implementation_type = implementation_type
        self.instance_deployment_config = instance_deployment_config
        self.instance_deployment_template = instance_deployment_template
        self.service_deployment_id = service_deployment_id
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        self.on_failure_policy = on_failure_policy
        self.service_id = service_id
        self.transport_type = transport_type
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

ServiceInstance._set_binding_type(type.StructType(
    'com.vmware.nsx.model.service_instance', {
        'attachment_point': type.OptionalType(type.StringType()),
        'deployed_to': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceReference'))),
        'deployment_mode': type.OptionalType(type.StringType()),
        'deployment_spec_name': type.OptionalType(type.StringType()),
        'implementation_type': type.OptionalType(type.StringType()),
        'instance_deployment_config': type.OptionalType(type.ReferenceType(__name__, 'InstanceDeploymentConfig')),
        'instance_deployment_template': type.OptionalType(type.ReferenceType(__name__, 'DeploymentTemplate')),
        'service_deployment_id': type.OptionalType(type.StringType()),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'on_failure_policy': type.OptionalType(type.StringType()),
        'service_id': type.OptionalType(type.StringType()),
        'transport_type': type.OptionalType(type.StringType()),
    },
    ServiceInstance,
    False,
    None))



class ServiceInstanceHealthStatus(VapiStruct):
    """
    Health Status of a third party partner VM.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'connect_timestamp': 'connect_timestamp',
                            'is_stale': 'is_stale',
                            'is_sva_mux_incompatible': 'is_sva_mux_incompatible',
                            'mux_connected_status': 'mux_connected_status',
                            'mux_incompatible_version': 'mux_incompatible_version',
                            'solution_status': 'solution_status',
                            'solution_version': 'solution_version',
                            'sync_time': 'sync_time',
                            }

    def __init__(self,
                 connect_timestamp=None,
                 is_stale=None,
                 is_sva_mux_incompatible=None,
                 mux_connected_status=None,
                 mux_incompatible_version=None,
                 solution_status=None,
                 solution_version=None,
                 sync_time=None,
                ):
        """
        :type  connect_timestamp: :class:`str` or ``None``
        :param connect_timestamp: Latest timestamp when mux was connected to SVA.
        :type  is_stale: :class:`bool` or ``None``
        :param is_stale: The parameter is set if the last received health status is older
            than the predefined interval.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  is_sva_mux_incompatible: :class:`bool` or ``None``
        :param is_sva_mux_incompatible: Protocol version might be different in both Mux and SVA.
        :type  mux_connected_status: :class:`str` or ``None``
        :param mux_connected_status: Status of multiplexer which forwards the events from guest virtual
            machines to the partner appliance.
        :type  mux_incompatible_version: :class:`str` or ``None``
        :param mux_incompatible_version: Mux version when Mux and SVA are incompatible
        :type  solution_status: :class:`str` or ``None``
        :param solution_status: Status of third party partner solution application.
        :type  solution_version: :class:`str` or ``None``
        :param solution_version: Version of third party partner solution application.
        :type  sync_time: :class:`str` or ``None``
        :param sync_time: Latest timestamp when health status is received.
        """
        self.connect_timestamp = connect_timestamp
        self.is_stale = is_stale
        self.is_sva_mux_incompatible = is_sva_mux_incompatible
        self.mux_connected_status = mux_connected_status
        self.mux_incompatible_version = mux_incompatible_version
        self.solution_status = solution_status
        self.solution_version = solution_version
        self.sync_time = sync_time
        VapiStruct.__init__(self)


ServiceInstanceHealthStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.service_instance_health_status', {
        'connect_timestamp': type.OptionalType(type.StringType()),
        'is_stale': type.OptionalType(type.BooleanType()),
        'is_sva_mux_incompatible': type.OptionalType(type.BooleanType()),
        'mux_connected_status': type.OptionalType(type.StringType()),
        'mux_incompatible_version': type.OptionalType(type.StringType()),
        'solution_status': type.OptionalType(type.StringType()),
        'solution_version': type.OptionalType(type.StringType()),
        'sync_time': type.OptionalType(type.StringType()),
    },
    ServiceInstanceHealthStatus,
    False,
    None))



class ServiceInstanceListResult(VapiStruct):
    """
    Service Instance List

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param results: List of the Service-Insertion ServicesInstances. The list has to be
            homogenous.
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`BaseServiceInstance`. When methods return a value of this
            class as a return value, the attribute will contain all the
            attributes defined in :class:`BaseServiceInstance`.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


ServiceInstanceListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.service_instance_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'BaseServiceInstance')]))),
    },
    ServiceInstanceListResult,
    False,
    None))



class ServiceInstanceNSGroups(VapiStruct):
    """
    ServiceInstanceNSGroups contains list of NS Groups referenced in
    North-South Service Insertion Rules for a particular Service Instance.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'nsroups': 'nsroups',
                            }

    def __init__(self,
                 nsroups=None,
                ):
        """
        :type  nsroups: :class:`list` of :class:`NSGroupInfo` or ``None``
        :param nsroups: List of NSGroups Used in ServiceInsertion Rules.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.nsroups = nsroups
        VapiStruct.__init__(self)


ServiceInstanceNSGroups._set_binding_type(type.StructType(
    'com.vmware.nsx.model.service_instance_NS_groups', {
        'nsroups': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NSGroupInfo'))),
    },
    ServiceInstanceNSGroups,
    False,
    None))



class ServiceInstanceStatus(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'configuration_issue': 'configuration_issue',
                            'instance_deployment_status': 'instance_deployment_status',
                            'instance_health_status': 'instance_health_status',
                            'service_instance_id': 'service_instance_id',
                            }

    def __init__(self,
                 configuration_issue=None,
                 instance_deployment_status=None,
                 instance_health_status=None,
                 service_instance_id=None,
                ):
        """
        :type  configuration_issue: :class:`SVMConfigureIssue` or ``None``
        :param configuration_issue: This object contains the list of issues which might come during
            post deployment configuration for a particular service instance.
        :type  instance_deployment_status: :class:`ServiceDeploymentStatus` or ``None``
        :param instance_deployment_status: Deployment status of NXGI Partner Service-VM.
        :type  instance_health_status: :class:`ServiceInstanceHealthStatus` or ``None``
        :param instance_health_status: Health status of NXGI components on Partner Service-VM.
        :type  service_instance_id: :class:`str` or ``None``
        :param service_instance_id: Id of an instantiation of a registered service.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.configuration_issue = configuration_issue
        self.instance_deployment_status = instance_deployment_status
        self.instance_health_status = instance_health_status
        self.service_instance_id = service_instance_id
        VapiStruct.__init__(self)


ServiceInstanceStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.service_instance_status', {
        'configuration_issue': type.OptionalType(type.ReferenceType(__name__, 'SVMConfigureIssue')),
        'instance_deployment_status': type.OptionalType(type.ReferenceType(__name__, 'ServiceDeploymentStatus')),
        'instance_health_status': type.OptionalType(type.ReferenceType(__name__, 'ServiceInstanceHealthStatus')),
        'service_instance_id': type.OptionalType(type.StringType()),
    },
    ServiceInstanceStatus,
    False,
    None))



class ServiceManager(VapiStruct):
    """
    Partner console endpoint information for enabling NSX to callback with
    events and status.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'authentication_scheme': 'authentication_scheme',
                            'port': 'port',
                            'server': 'server',
                            'service_ids': 'service_ids',
                            'thumbprint': 'thumbprint',
                            'uri': 'uri',
                            'vendor_id': 'vendor_id',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 authentication_scheme=None,
                 port=None,
                 server=None,
                 service_ids=None,
                 thumbprint=None,
                 uri=None,
                 vendor_id=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  authentication_scheme: :class:`CallbackAuthenticationScheme` or ``None``
        :param authentication_scheme: A CallbackAuthenticationScheme that describes how notification
            requests/callbacks from NSX, should authenticate to the server.
        :type  port: :class:`long` or ``None``
        :param port: Integer port value to specify a standard/non-standard HTTPS port.
            format: int64
        :type  server: :class:`str` or ``None``
        :param server: IP address or fully qualified domain name of the partner REST
            server.
        :type  service_ids: :class:`list` of :class:`ResourceReference` or ``None``
        :param service_ids: The IDs of services, provided by partner.
        :type  thumbprint: :class:`str` or ``None``
        :param thumbprint: Thumbprint (SHA-256 hash represented in lower case hex) for the
            certificate on the partner console. This will be required to
            establish secure communication with the console and to avoid
            man-in-the-middle attacks.
        :type  uri: :class:`str` or ``None``
        :param uri: URI on which notification requests should be made on the specified
            server.
        :type  vendor_id: :class:`str` or ``None``
        :param vendor_id: Id which is unique to a vendor or partner for which the service is
            created.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.authentication_scheme = authentication_scheme
        self.port = port
        self.server = server
        self.service_ids = service_ids
        self.thumbprint = thumbprint
        self.uri = uri
        self.vendor_id = vendor_id
        VapiStruct.__init__(self)


ServiceManager._set_binding_type(type.StructType(
    'com.vmware.nsx.model.service_manager', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'authentication_scheme': type.OptionalType(type.ReferenceType(__name__, 'CallbackAuthenticationScheme')),
        'port': type.OptionalType(type.IntegerType()),
        'server': type.OptionalType(type.StringType()),
        'service_ids': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceReference'))),
        'thumbprint': type.OptionalType(type.StringType()),
        'uri': type.OptionalType(type.StringType()),
        'vendor_id': type.OptionalType(type.StringType()),
    },
    ServiceManager,
    False,
    None))



class ServiceManagerListResult(VapiStruct):
    """
    Service Manager List Result

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`ServiceManager` or ``None``
        :param results: List of the Service-managers.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


ServiceManagerListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.service_manager_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ServiceManager'))),
    },
    ServiceManagerListResult,
    False,
    None))



class ServicePath(VapiStruct):
    """
    An instance of service chain that consists of forward and reverse service
    paths.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'forward_path': 'forward_path',
                            'reverse_path': 'reverse_path',
                            'service_chain_id': 'service_chain_id',
                            'service_chain_uuid': 'service_chain_uuid',
                            'service_path_id': 'service_path_id',
                            }

    def __init__(self,
                 forward_path=None,
                 reverse_path=None,
                 service_chain_id=None,
                 service_chain_uuid=None,
                 service_path_id=None,
                ):
        """
        :type  forward_path: :class:`UnidirectionalServicePath` or ``None``
        :param forward_path: Forward service path if available that applies to ingress traffic.
        :type  reverse_path: :class:`UnidirectionalServicePath` or ``None``
        :param reverse_path: Reverse service path if available that applies to egress traffic.
        :type  service_chain_id: :class:`long` or ``None``
        :param service_chain_id: A unique id of a service chain. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  service_chain_uuid: :class:`str` or ``None``
        :param service_chain_uuid: Uuid of a service chain.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  service_path_id: :class:`long` or ``None``
        :param service_path_id: Unique identifier of a service path. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.forward_path = forward_path
        self.reverse_path = reverse_path
        self.service_chain_id = service_chain_id
        self.service_chain_uuid = service_chain_uuid
        self.service_path_id = service_path_id
        VapiStruct.__init__(self)


ServicePath._set_binding_type(type.StructType(
    'com.vmware.nsx.model.service_path', {
        'forward_path': type.OptionalType(type.ReferenceType(__name__, 'UnidirectionalServicePath')),
        'reverse_path': type.OptionalType(type.ReferenceType(__name__, 'UnidirectionalServicePath')),
        'service_chain_id': type.OptionalType(type.IntegerType()),
        'service_chain_uuid': type.OptionalType(type.StringType()),
        'service_path_id': type.OptionalType(type.IntegerType()),
    },
    ServicePath,
    False,
    None))



class ServicePathHop(VapiStruct):
    """
    Represents a service VM implementing a particular service in a service
    chain

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    ACTION_SERVICE_ACTION_INVALID = "SERVICE_ACTION_INVALID"
    """


    """
    ACTION_COPY = "COPY"
    """


    """
    ACTION_REDIRECT = "REDIRECT"
    """


    """



    _canonical_to_pep_names = {
                            'action': 'action',
                            'can_decrement_si': 'can_decrement_si',
                            'in_maintenance_mode': 'in_maintenance_mode',
                            'is_active_from_ccp': 'is_active_from_ccp',
                            'is_active_from_dp': 'is_active_from_dp',
                            'is_active_from_mp': 'is_active_from_mp',
                            'mac_address': 'mac_address',
                            'nsh_liveness_support': 'nsh_liveness_support',
                            'vif': 'vif',
                            }

    def __init__(self,
                 action=None,
                 can_decrement_si=None,
                 in_maintenance_mode=None,
                 is_active_from_ccp=None,
                 is_active_from_dp=None,
                 is_active_from_mp=None,
                 mac_address=None,
                 nsh_liveness_support=None,
                 vif=None,
                ):
        """
        :type  action: :class:`str` or ``None``
        :param action: Possible values are: 
            
            * :attr:`ServicePathHop.ACTION_SERVICE_ACTION_INVALID`
            * :attr:`ServicePathHop.ACTION_COPY`
            * :attr:`ServicePathHop.ACTION_REDIRECT`
            
            Action that will be taken by the corresponding service VM of the
            hop.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  can_decrement_si: :class:`bool` or ``None``
        :param can_decrement_si: Indicating whether service is configured to decrement SI field in
            NSH metadata.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  in_maintenance_mode: :class:`bool` or ``None``
        :param in_maintenance_mode: Indicating the maintenance mode of the corresponding service VM.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  is_active_from_ccp: :class:`bool` or ``None``
        :param is_active_from_ccp: Indicating whether the corresponding service VM is active or not
            per CCP.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  is_active_from_dp: :class:`bool` or ``None``
        :param is_active_from_dp: Indicating whether the corresponding service VM is active or not
            per DP.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  is_active_from_mp: :class:`bool` or ``None``
        :param is_active_from_mp: Indicating whether the corresponding service VM is active or not
            per MP.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  mac_address: :class:`str` or ``None``
        :param mac_address: MAC address of the virtual network interface.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  nsh_liveness_support: :class:`bool` or ``None``
        :param nsh_liveness_support: Indicating whether NSH liveness is supported or not by the
            corresponding service VM.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  vif: :class:`str` or ``None``
        :param vif: ID of the virtual network interface.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.action = action
        self.can_decrement_si = can_decrement_si
        self.in_maintenance_mode = in_maintenance_mode
        self.is_active_from_ccp = is_active_from_ccp
        self.is_active_from_dp = is_active_from_dp
        self.is_active_from_mp = is_active_from_mp
        self.mac_address = mac_address
        self.nsh_liveness_support = nsh_liveness_support
        self.vif = vif
        VapiStruct.__init__(self)


ServicePathHop._set_binding_type(type.StructType(
    'com.vmware.nsx.model.service_path_hop', {
        'action': type.OptionalType(type.StringType()),
        'can_decrement_si': type.OptionalType(type.BooleanType()),
        'in_maintenance_mode': type.OptionalType(type.BooleanType()),
        'is_active_from_ccp': type.OptionalType(type.BooleanType()),
        'is_active_from_dp': type.OptionalType(type.BooleanType()),
        'is_active_from_mp': type.OptionalType(type.BooleanType()),
        'mac_address': type.OptionalType(type.StringType()),
        'nsh_liveness_support': type.OptionalType(type.BooleanType()),
        'vif': type.OptionalType(type.StringType()),
    },
    ServicePathHop,
    False,
    None))



class ServicePathListResult(VapiStruct):
    """
    Service path list

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`ServicePath` or ``None``
        :param results: List of homogenous service paths
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


ServicePathListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.service_path_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ServicePath'))),
    },
    ServicePathListResult,
    False,
    None))



class ServiceProfileNSGroups(VapiStruct):
    """
    ServiceProfileNSGroups contains list of NS Groups referenced in Service
    Insertion Rules. To be considered, Service profile must be part of a
    Service Chain and that Service chain must be used in a Rule.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'nsroups': 'nsroups',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 nsroups=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  nsroups: :class:`list` of :class:`NSGroupInfo` or ``None``
        :param nsroups: List of NSGroups Used in ServiceInsertion Rules.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.nsroups = nsroups
        VapiStruct.__init__(self)


ServiceProfileNSGroups._set_binding_type(type.StructType(
    'com.vmware.nsx.model.service_profile_NS_groups', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'nsroups': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NSGroupInfo'))),
    },
    ServiceProfileNSGroups,
    False,
    None))



class ServiceRouterAllocationConfig(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'allocation_pool': 'allocation_pool',
                            'edge_cluster_id': 'edge_cluster_id',
                            'edge_cluster_member_indices': 'edge_cluster_member_indices',
                            }

    def __init__(self,
                 allocation_pool=None,
                 edge_cluster_id=None,
                 edge_cluster_member_indices=None,
                ):
        """
        :type  allocation_pool: :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param allocation_pool: Logical router allocation can be tracked for specific services and
            services may have their own hard limits and allocation sizes. For
            example load balancer pool should be specified if load balancer
            service will be attached to logical router.
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`EdgeClusterMemberAllocationPool`. When methods return a
            value of this class as a return value, the attribute will contain
            all the attributes defined in
            :class:`EdgeClusterMemberAllocationPool`.
        :type  edge_cluster_id: :class:`str` or ``None``
        :param edge_cluster_id: To reallocate TIER1 logical router on new or existing edge cluster
        :type  edge_cluster_member_indices: :class:`list` of :class:`long` or ``None``
        :param edge_cluster_member_indices: For TIER 1 logical router, for manual placement of service router
            within the cluster, edge cluster member indices needs to be
            provided else same will be auto-allocated. You can provide maximum
            two indices for HA ACTIVE_STANDBY. format: int64
        """
        self.allocation_pool = allocation_pool
        self.edge_cluster_id = edge_cluster_id
        self.edge_cluster_member_indices = edge_cluster_member_indices
        VapiStruct.__init__(self)


ServiceRouterAllocationConfig._set_binding_type(type.StructType(
    'com.vmware.nsx.model.service_router_allocation_config', {
        'allocation_pool': type.OptionalType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'EdgeClusterMemberAllocationPool')])),
        'edge_cluster_id': type.OptionalType(type.StringType()),
        'edge_cluster_member_indices': type.OptionalType(type.ListType(type.IntegerType())),
    },
    ServiceRouterAllocationConfig,
    False,
    None))



class SessionLoginCredential(VapiStruct):
    """
    Details of session based login credential to login to server.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "SessionLoginCredential"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'session_id': 'session_id',
                            'thumbprint': 'thumbprint',
                            'credential_type': 'credential_type',
                            }

    def __init__(self,
                 session_id=None,
                 thumbprint=None,
                 credential_type='SessionLoginCredential',
                ):
        """
        :type  session_id: :class:`str` or ``None``
        :param session_id: The session_id to login to server.
        :type  thumbprint: :class:`str` or ``None``
        :param thumbprint: Thumbprint of the login server.
        :type  credential_type: :class:`str`
        :param credential_type: Possible values are 'UsernamePasswordLoginCredential',
            'VerifiableAsymmetricLoginCredential', 'SessionLoginCredential'.
        """
        self.session_id = session_id
        self.thumbprint = thumbprint
        self._credential_type = credential_type
        VapiStruct.__init__(self)

    @property
    def credential_type(self):
        """
        Return the discriminator value
        """
        return self._credential_type

SessionLoginCredential._set_binding_type(type.StructType(
    'com.vmware.nsx.model.session_login_credential', {
        'session_id': type.OptionalType(type.StringType()),
        'thumbprint': type.OptionalType(type.StringType()),
        'credential_type': type.StringType(),
    },
    SessionLoginCredential,
    False,
    None))



class SetPrincipalIdentityCertificateForFederationRequest(VapiStruct):
    """
    Data for setting a principal identity certificate

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    SERVICE_TYPE_LOCAL_MANAGER = "LOCAL_MANAGER"
    """


    """
    SERVICE_TYPE_GLOBAL_MANAGER = "GLOBAL_MANAGER"
    """


    """



    _canonical_to_pep_names = {
                            'cert_id': 'cert_id',
                            'service_type': 'service_type',
                            }

    def __init__(self,
                 cert_id=None,
                 service_type=None,
                ):
        """
        :type  cert_id: :class:`str` or ``None``
        :param cert_id: Id of the certificate
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  service_type: :class:`str` or ``None``
        :param service_type: Possible values are: 
            
            *
              :attr:`SetPrincipalIdentityCertificateForFederationRequest.SERVICE_TYPE_LOCAL_MANAGER`
            *
              :attr:`SetPrincipalIdentityCertificateForFederationRequest.SERVICE_TYPE_GLOBAL_MANAGER`
            
             Service type for which the certificate should be used.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.cert_id = cert_id
        self.service_type = service_type
        VapiStruct.__init__(self)


SetPrincipalIdentityCertificateForFederationRequest._set_binding_type(type.StructType(
    'com.vmware.nsx.model.set_principal_identity_certificate_for_federation_request', {
        'cert_id': type.OptionalType(type.StringType()),
        'service_type': type.OptionalType(type.StringType()),
    },
    SetPrincipalIdentityCertificateForFederationRequest,
    False,
    None))



class SftpProtocol(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "SftpProtocol"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'authentication_scheme': 'authentication_scheme',
                            'ssh_fingerprint': 'ssh_fingerprint',
                            'name': 'name',
                            }

    def __init__(self,
                 authentication_scheme=None,
                 ssh_fingerprint=None,
                 name='SftpProtocol',
                ):
        """
        :type  authentication_scheme: :class:`PasswordAuthenticationScheme` or ``None``
        :param authentication_scheme: Scheme to authenticate if required
        :type  ssh_fingerprint: :class:`str` or ``None``
        :param ssh_fingerprint: SSH fingerprint of server
        :type  name: :class:`str`
        :param name: Possible values are: 
            
            * :attr:`Protocol.NAME_HTTP`
            * :attr:`Protocol.NAME_HTTPS`
            * :attr:`Protocol.NAME_SCP`
            * :attr:`Protocol.NAME_SFTP`
            
             Protocol name
        """
        self.authentication_scheme = authentication_scheme
        self.ssh_fingerprint = ssh_fingerprint
        self._name = name
        VapiStruct.__init__(self)

    @property
    def name(self):
        """
        Return the discriminator value
        """
        return self._name

SftpProtocol._set_binding_type(type.StructType(
    'com.vmware.nsx.model.sftp_protocol', {
        'authentication_scheme': type.OptionalType(type.ReferenceType(__name__, 'PasswordAuthenticationScheme')),
        'ssh_fingerprint': type.OptionalType(type.StringType()),
        'name': type.StringType(),
    },
    SftpProtocol,
    False,
    None))



class SnmpProperties(VapiStruct):
    """
    This object contains SNMP v2c and SNMP v3 properties.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'v2c': 'v2c',
                            'v3': 'v3',
                            }

    def __init__(self,
                 v2c=None,
                 v3=None,
                ):
        """
        :type  v2c: :class:`Snmpv2cProperties` or ``None``
        :param v2c: SNMP v2c properties
        :type  v3: :class:`Snmpv3Properties` or ``None``
        :param v3: SNMP v3 properties
        """
        self.v2c = v2c
        self.v3 = v3
        VapiStruct.__init__(self)


SnmpProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.snmp_properties', {
        'v2c': type.OptionalType(type.ReferenceType(__name__, 'Snmpv2cProperties')),
        'v3': type.OptionalType(type.ReferenceType(__name__, 'Snmpv3Properties')),
    },
    SnmpProperties,
    False,
    None))



class SnmpServiceProperties(VapiStruct):
    """
    SNMP Service properties

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    V3AUTH_PROTOCOL_SHA1 = "SHA1"
    """


    """
    V3PRIV_PROTOCOL_AES128 = "AES128"
    """


    """



    _canonical_to_pep_names = {
                            'communities': 'communities',
                            'start_on_boot': 'start_on_boot',
                            'v2_configured': 'v2_configured',
                            'v3_auth_protocol': 'v3_auth_protocol',
                            'v3_configured': 'v3_configured',
                            'v3_priv_protocol': 'v3_priv_protocol',
                            'v3_users': 'v3_users',
                            }

    def __init__(self,
                 communities=None,
                 start_on_boot=None,
                 v2_configured=None,
                 v3_auth_protocol=None,
                 v3_configured=None,
                 v3_priv_protocol=None,
                 v3_users=None,
                ):
        """
        :type  communities: :class:`list` of :class:`str` or ``None``
        :param communities: SNMP v1, v2c community strings
        :type  start_on_boot: :class:`bool` or ``None``
        :param start_on_boot: Start when system boots
        :type  v2_configured: :class:`bool` or ``None``
        :param v2_configured: SNMP v2 is configured or not
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  v3_auth_protocol: :class:`str` or ``None``
        :param v3_auth_protocol: Possible values are: 
            
            * :attr:`SnmpServiceProperties.V3AUTH_PROTOCOL_SHA1`
            
             SNMP v3 auth protocol
        :type  v3_configured: :class:`bool` or ``None``
        :param v3_configured: SNMP v3 is configured or not
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  v3_priv_protocol: :class:`str` or ``None``
        :param v3_priv_protocol: Possible values are: 
            
            * :attr:`SnmpServiceProperties.V3PRIV_PROTOCOL_AES128`
            
             SNMP v3 private protocol
        :type  v3_users: :class:`list` of :class:`SnmpV3User` or ``None``
        :param v3_users: SNMP v3 users information
        """
        self.communities = communities
        self.start_on_boot = start_on_boot
        self.v2_configured = v2_configured
        self.v3_auth_protocol = v3_auth_protocol
        self.v3_configured = v3_configured
        self.v3_priv_protocol = v3_priv_protocol
        self.v3_users = v3_users
        VapiStruct.__init__(self)


SnmpServiceProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.snmp_service_properties', {
        'communities': type.OptionalType(type.ListType(type.StringType())),
        'start_on_boot': type.OptionalType(type.BooleanType()),
        'v2_configured': type.OptionalType(type.BooleanType()),
        'v3_auth_protocol': type.OptionalType(type.StringType()),
        'v3_configured': type.OptionalType(type.BooleanType()),
        'v3_priv_protocol': type.OptionalType(type.StringType()),
        'v3_users': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'SnmpV3User'))),
    },
    SnmpServiceProperties,
    False,
    None))



class SnmpV3User(VapiStruct):
    """
    SNMP v3 user properties

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'auth_password': 'auth_password',
                            'priv_password': 'priv_password',
                            'user_id': 'user_id',
                            }

    def __init__(self,
                 auth_password=None,
                 priv_password=None,
                 user_id=None,
                ):
        """
        :type  auth_password: :class:`str` or ``None``
        :param auth_password: SNMP v3 user auth password
        :type  priv_password: :class:`str` or ``None``
        :param priv_password: SNMP v3 user private password
        :type  user_id: :class:`str` or ``None``
        :param user_id: SNMP v3 user ID
        """
        self.auth_password = auth_password
        self.priv_password = priv_password
        self.user_id = user_id
        VapiStruct.__init__(self)


SnmpV3User._set_binding_type(type.StructType(
    'com.vmware.nsx.model.snmp_v3_user', {
        'auth_password': type.OptionalType(type.StringType()),
        'priv_password': type.OptionalType(type.StringType()),
        'user_id': type.OptionalType(type.StringType()),
    },
    SnmpV3User,
    False,
    None))



class Snmpv2cCommunity(VapiStruct):
    """
    This object contains SNMP v2c community identifier, shared secret and
    access properties.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    ACCESS_ONLY = "READ_ONLY"
    """


    """



    _canonical_to_pep_names = {
                            'access': 'access',
                            'community_name': 'community_name',
                            'community_string': 'community_string',
                            }

    def __init__(self,
                 access=None,
                 community_name=None,
                 community_string=None,
                ):
        """
        :type  access: :class:`str` or ``None``
        :param access: Possible values are: 
            
            * :attr:`Snmpv2cCommunity.ACCESS_ONLY`
            
             Access permissions for polling NSX nodes over SNMP v2c.
        :type  community_name: :class:`str` or ``None``
        :param community_name: Unique, non-sensitive community name to identify community.
        :type  community_string: :class:`str` or ``None``
        :param community_string: Community string. This is considered a shared secret and therefore
            sensitive information. This field is required when adding a
            community. When updating a community, do not include this field in
            the request. If this field is present in an update request, it will
            be considered as a new value for community string.
        """
        self.access = access
        self.community_name = community_name
        self.community_string = community_string
        VapiStruct.__init__(self)


Snmpv2cCommunity._set_binding_type(type.StructType(
    'com.vmware.nsx.model.snmpv2c_community', {
        'access': type.OptionalType(type.StringType()),
        'community_name': type.OptionalType(type.StringType()),
        'community_string': type.OptionalType(type.StringType()),
    },
    Snmpv2cCommunity,
    False,
    None))



class Snmpv2cProperties(VapiStruct):
    """
    This object contains list of SNMP v2c communities used to poll NSX nodes
    over SNMP and list of SNMP v2c targets used to receive SNMP
    traps/notifications from NSX nodes.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'communities': 'communities',
                            'targets': 'targets',
                            }

    def __init__(self,
                 communities=None,
                 targets=None,
                ):
        """
        :type  communities: :class:`list` of :class:`Snmpv2cCommunity` or ``None``
        :param communities: List of SNMP v2c communities allowed to poll NSX nodes over SNMP
            v2c.
        :type  targets: :class:`list` of :class:`Snmpv2cTarget` or ``None``
        :param targets: List of SNMP v2c targets/receivers where SNMP v2c
            traps/notifications will be sent from NSX nodes.
        """
        self.communities = communities
        self.targets = targets
        VapiStruct.__init__(self)


Snmpv2cProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.snmpv2c_properties', {
        'communities': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Snmpv2cCommunity'))),
        'targets': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Snmpv2cTarget'))),
    },
    Snmpv2cProperties,
    False,
    None))



class Snmpv2cTarget(VapiStruct):
    """
    This object contains SNMP v2c target/receiver where SNMP
    traps/notifications will be sent.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'community_name': 'community_name',
                            'community_string': 'community_string',
                            'port': 'port',
                            'server': 'server',
                            }

    def __init__(self,
                 community_name=None,
                 community_string=None,
                 port=None,
                 server=None,
                ):
        """
        :type  community_name: :class:`str` or ``None``
        :param community_name: Unique non-sensitive community name to identify community.
        :type  community_string: :class:`str` or ``None``
        :param community_string: Community string (shared secret). This field is required when
            adding a community target. When updating a community target, do not
            include this field in the request. If this field is present in an
            update request, it will be considered as a new value for community
            string.
        :type  port: :class:`long` or ``None``
        :param port: SNMP v2c target server's port number. format: int64
        :type  server: :class:`str` or ``None``
        :param server: SNMP v2c target server's IP or FQDN. format: hostname-or-ipv4
        """
        self.community_name = community_name
        self.community_string = community_string
        self.port = port
        self.server = server
        VapiStruct.__init__(self)


Snmpv2cTarget._set_binding_type(type.StructType(
    'com.vmware.nsx.model.snmpv2c_target', {
        'community_name': type.OptionalType(type.StringType()),
        'community_string': type.OptionalType(type.StringType()),
        'port': type.OptionalType(type.IntegerType()),
        'server': type.OptionalType(type.StringType()),
    },
    Snmpv2cTarget,
    False,
    None))



class Snmpv3Properties(VapiStruct):
    """
    This object contains list of SNMP v3 users used to poll NSX nodes over SNMP
    and list of SNMP v3 targets used to receive SNMP traps/notifications from
    NSX nodes. Users specified in a SNMP v3 target must exist in the list of
    SNMP v3 users.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    AUTH_PROTOCOL_SHA1 = "SHA1"
    """


    """
    PRIV_PROTOCOL_AES128 = "AES128"
    """


    """



    _canonical_to_pep_names = {
                            'auth_protocol': 'auth_protocol',
                            'priv_protocol': 'priv_protocol',
                            'targets': 'targets',
                            'users': 'users',
                            }

    def __init__(self,
                 auth_protocol=None,
                 priv_protocol=None,
                 targets=None,
                 users=None,
                ):
        """
        :type  auth_protocol: :class:`str` or ``None``
        :param auth_protocol: Possible values are: 
            
            * :attr:`Snmpv3Properties.AUTH_PROTOCOL_SHA1`
            
             Authentication protocol used for SNMP v3 communication.
        :type  priv_protocol: :class:`str` or ``None``
        :param priv_protocol: Possible values are: 
            
            * :attr:`Snmpv3Properties.PRIV_PROTOCOL_AES128`
            
             Privacy protocol used for SNMP v3 communication.
        :type  targets: :class:`list` of :class:`Snmpv3Target` or ``None``
        :param targets: List of SNMP v3 targets/receivers where SNMP v3 traps/notifications
            will be sent from NSX nodes.
        :type  users: :class:`list` of :class:`Snmpv3User` or ``None``
        :param users: List of SNMP v3 users allowed to poll NSX nodes over SNMP. Also,
            users specified in a SNMP v3 target must exist in this list.
        """
        self.auth_protocol = auth_protocol
        self.priv_protocol = priv_protocol
        self.targets = targets
        self.users = users
        VapiStruct.__init__(self)


Snmpv3Properties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.snmpv3_properties', {
        'auth_protocol': type.OptionalType(type.StringType()),
        'priv_protocol': type.OptionalType(type.StringType()),
        'targets': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Snmpv3Target'))),
        'users': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Snmpv3User'))),
    },
    Snmpv3Properties,
    False,
    None))



class Snmpv3Target(VapiStruct):
    """
    This object contains SNMP v3 target/receiver where SNMP traps/notifications
    will be sent.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    SECURITY_LEVEL_PRIV = "AUTH_PRIV"
    """


    """



    _canonical_to_pep_names = {
                            'port': 'port',
                            'security_level': 'security_level',
                            'server': 'server',
                            'user_id': 'user_id',
                            }

    def __init__(self,
                 port=None,
                 security_level=None,
                 server=None,
                 user_id=None,
                ):
        """
        :type  port: :class:`long` or ``None``
        :param port: SNMP v3 target server's port. format: int64
        :type  security_level: :class:`str` or ``None``
        :param security_level: Possible values are: 
            
            * :attr:`Snmpv3Target.SECURITY_LEVEL_PRIV`
            
            Security level indicates whether SNMP communication involves
            authentication and privacy protocols for this user. Value
            \"AUTH_PRIV\" indicates both authentication and privacy protocols
            will be used for SNMP communication.
        :type  server: :class:`str` or ``None``
        :param server: SNMP v3 target server's IP or FQDN. format: hostname-or-ipv4
        :type  user_id: :class:`str` or ``None``
        :param user_id: SNMP v3 user id used to notify target server. This SNMP v3 user
            should already be added in this profile.
        """
        self.port = port
        self.security_level = security_level
        self.server = server
        self.user_id = user_id
        VapiStruct.__init__(self)


Snmpv3Target._set_binding_type(type.StructType(
    'com.vmware.nsx.model.snmpv3_target', {
        'port': type.OptionalType(type.IntegerType()),
        'security_level': type.OptionalType(type.StringType()),
        'server': type.OptionalType(type.StringType()),
        'user_id': type.OptionalType(type.StringType()),
    },
    Snmpv3Target,
    False,
    None))



class Snmpv3User(VapiStruct):
    """
    This object contains properties for a SNMP v3 user that can be used to
    receive SNMP traps/notifications from NSX and/or poll NSX nodes over SNMP.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    ACCESS_ONLY = "READ_ONLY"
    """


    """
    SECURITY_LEVEL_PRIV = "AUTH_PRIV"
    """


    """



    _canonical_to_pep_names = {
                            'access': 'access',
                            'auth_password': 'auth_password',
                            'priv_password': 'priv_password',
                            'security_level': 'security_level',
                            'user_id': 'user_id',
                            }

    def __init__(self,
                 access=None,
                 auth_password=None,
                 priv_password=None,
                 security_level=None,
                 user_id=None,
                ):
        """
        :type  access: :class:`str` or ``None``
        :param access: Possible values are: 
            
            * :attr:`Snmpv3User.ACCESS_ONLY`
            
             Access permissions for polling NSX nodes over SNMP v3.
        :type  auth_password: :class:`str` or ``None``
        :param auth_password: Authentication password used for SNMP v3 communication. This field
            is required when adding a user. When updating a user, do not
            include this field in the request. If this field is present in an
            update request, it will be considered as a new value for
            authentication password.
        :type  priv_password: :class:`str` or ``None``
        :param priv_password: Privacy password used for SNMP v3 communication. This field is
            required when adding a user. When updating a user, do not include
            this field in the request. If this field is present in an update
            request, it will be considered as a new value for privacy password.
        :type  security_level: :class:`str` or ``None``
        :param security_level: Possible values are: 
            
            * :attr:`Snmpv3User.SECURITY_LEVEL_PRIV`
            
            Security level indicates whether SNMP communication involves
            authentication and privacy protocols for this user. Value
            \"AUTH_PRIV\" indicates both authentication and privacy protocols
            will be used for SNMP communication.
        :type  user_id: :class:`str` or ``None``
        :param user_id: Unique SNMP v3 user id.
        """
        self.access = access
        self.auth_password = auth_password
        self.priv_password = priv_password
        self.security_level = security_level
        self.user_id = user_id
        VapiStruct.__init__(self)


Snmpv3User._set_binding_type(type.StructType(
    'com.vmware.nsx.model.snmpv3_user', {
        'access': type.OptionalType(type.StringType()),
        'auth_password': type.OptionalType(type.StringType()),
        'priv_password': type.OptionalType(type.StringType()),
        'security_level': type.OptionalType(type.StringType()),
        'user_id': type.OptionalType(type.StringType()),
    },
    Snmpv3User,
    False,
    None))



class SoftwareModule(VapiStruct):
    """
    Software module details

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'module_name': 'module_name',
                            'module_version': 'module_version',
                            }

    def __init__(self,
                 module_name=None,
                 module_version=None,
                ):
        """
        :type  module_name: :class:`str` or ``None``
        :param module_name: Name of the module in the node
        :type  module_version: :class:`str` or ``None``
        :param module_version: Version of the module in the node
        """
        self.module_name = module_name
        self.module_version = module_version
        VapiStruct.__init__(self)


SoftwareModule._set_binding_type(type.StructType(
    'com.vmware.nsx.model.software_module', {
        'module_name': type.OptionalType(type.StringType()),
        'module_version': type.OptionalType(type.StringType()),
    },
    SoftwareModule,
    False,
    None))



class SoftwareModuleResult(VapiStruct):
    """
    Software module result

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'software_modules': 'software_modules',
                            }

    def __init__(self,
                 software_modules=None,
                ):
        """
        :type  software_modules: :class:`list` of :class:`SoftwareModule` or ``None``
        :param software_modules: Software module results
        """
        self.software_modules = software_modules
        VapiStruct.__init__(self)


SoftwareModuleResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.software_module_result', {
        'software_modules': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'SoftwareModule'))),
    },
    SoftwareModuleResult,
    False,
    None))



class SolutionConfig(VapiStruct):
    """
    Solution Config would contain Vendor specific information required for
    configuring the NXGI partner Service after deployment.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'control_ip': 'control_ip',
                            'listen_port': 'listen_port',
                            'service_id': 'service_id',
                            'solution_id': 'solution_id',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 control_ip=None,
                 listen_port=None,
                 service_id=None,
                 solution_id=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  control_ip: :class:`str` or ``None``
        :param control_ip: Partner needs to specify their assigned control IP with which they
            have configured their OVFs. format: ipv4
        :type  listen_port: :class:`long` or ``None``
        :param listen_port: Partner needs to specify their port on which their solution
            application which consumes NXGI EPSec library listens. format:
            int32
        :type  service_id: :class:`str` or ``None``
        :param service_id: The service to which the service profile belongs.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  solution_id: :class:`str` or ``None``
        :param solution_id: Partner needs to specify Solution Id assigned by VMware.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.control_ip = control_ip
        self.listen_port = listen_port
        self.service_id = service_id
        self.solution_id = solution_id
        VapiStruct.__init__(self)


SolutionConfig._set_binding_type(type.StructType(
    'com.vmware.nsx.model.solution_config', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'control_ip': type.OptionalType(type.StringType()),
        'listen_port': type.OptionalType(type.IntegerType()),
        'service_id': type.OptionalType(type.StringType()),
        'solution_id': type.OptionalType(type.StringType()),
    },
    SolutionConfig,
    False,
    None))



class SolutionConfigListResult(VapiStruct):
    """
    Solution Config List

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`SolutionConfig` or ``None``
        :param results: List of the Solution Config.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


SolutionConfigListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.solution_config_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'SolutionConfig'))),
    },
    SolutionConfigListResult,
    False,
    None))



class SourceEntity(VapiStruct):
    """
    Service insertion data path inserts unique 'source node id' value into each
    packet before it received by Service VM. This value can be resolved to
    multiple Source Entities. It represents source of the packets.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    SOURCE_ENTITY_TYPE_NETWORK_INTERFACE = "VIRTUAL_NETWORK_INTERFACE"
    """


    """
    SOURCE_ENTITY_TYPE_MACHINE = "VIRTUAL_MACHINE"
    """


    """



    _canonical_to_pep_names = {
                            'source_entity_id': 'source_entity_id',
                            'source_entity_type': 'source_entity_type',
                            }

    def __init__(self,
                 source_entity_id=None,
                 source_entity_type=None,
                ):
        """
        :type  source_entity_id: :class:`str` or ``None``
        :param source_entity_id: UUID of Source entity
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  source_entity_type: :class:`str` or ``None``
        :param source_entity_type: Possible values are: 
            
            * :attr:`SourceEntity.SOURCE_ENTITY_TYPE_NETWORK_INTERFACE`
            * :attr:`SourceEntity.SOURCE_ENTITY_TYPE_MACHINE`
            
            Type of source entity. Currently source value can be resolved to
            VIF and Virtual Machine.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.source_entity_id = source_entity_id
        self.source_entity_type = source_entity_type
        VapiStruct.__init__(self)


SourceEntity._set_binding_type(type.StructType(
    'com.vmware.nsx.model.source_entity', {
        'source_entity_id': type.OptionalType(type.StringType()),
        'source_entity_type': type.OptionalType(type.StringType()),
    },
    SourceEntity,
    False,
    None))



class SourceEntityResult(VapiStruct):
    """
    Service Entity List

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`SourceEntity` or ``None``
        :param results: List of the Service Entities
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


SourceEntityResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.source_entity_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'SourceEntity'))),
    },
    SourceEntityResult,
    False,
    None))



class SourceNsxApiEndpoint(VapiStruct):
    """
    Details about an existing NSX manager to be migrated

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'auth_token': 'auth_token',
                            'ip': 'ip',
                            'nsx_password': 'nsx_password',
                            'nsx_syncrole': 'nsx_syncrole',
                            'nsx_username': 'nsx_username',
                            'nsx_version': 'nsx_version',
                            'vc_ip': 'vc_ip',
                            'vc_password': 'vc_password',
                            'vc_port': 'vc_port',
                            'vc_username': 'vc_username',
                            'vc_version': 'vc_version',
                            }

    def __init__(self,
                 auth_token=None,
                 ip=None,
                 nsx_password=None,
                 nsx_syncrole=None,
                 nsx_username=None,
                 nsx_version=None,
                 vc_ip=None,
                 vc_password=None,
                 vc_port=None,
                 vc_username=None,
                 vc_version=None,
                ):
        """
        :type  auth_token: :class:`str` or ``None``
        :param auth_token: Auth token used to make REST calls to source NSX API endpoint. This
            field is not applicable in case of vSphere network migration.
        :type  ip: :class:`str` or ``None``
        :param ip: IP address or hostname of a source NSX API endpoint. This field is
            not applicable in case of vSphere network migration. format:
            hostname-or-ip
        :type  nsx_password: :class:`str` or ``None``
        :param nsx_password: Password for connecting to NSX manager. This field is not
            applicable in case of vSphere network migration.
        :type  nsx_syncrole: :class:`str` or ``None``
        :param nsx_syncrole: Signifies Universal Sync role status (STANDALONE, PRIMARY,
            SECONDARY) of a source NSX API endpoint.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  nsx_username: :class:`str` or ``None``
        :param nsx_username: Username for connecting to NSX manager. This field is not
            applicable in case of vSphere network migration.
        :type  nsx_version: :class:`str` or ``None``
        :param nsx_version: Build version (major, minor, patch) of a source NSX API endpoint.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  vc_ip: :class:`str` or ``None``
        :param vc_ip: IP address or host name of VC. format: hostname-or-ip
        :type  vc_password: :class:`str` or ``None``
        :param vc_password: Password for connecting to VC.
        :type  vc_port: :class:`long` or ``None``
        :param vc_port: VC port that will be used to fetch details. format: int32
        :type  vc_username: :class:`str` or ``None``
        :param vc_username: Username for connecting to VC.
        :type  vc_version: :class:`str` or ``None``
        :param vc_version: Build version of VC.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.auth_token = auth_token
        self.ip = ip
        self.nsx_password = nsx_password
        self.nsx_syncrole = nsx_syncrole
        self.nsx_username = nsx_username
        self.nsx_version = nsx_version
        self.vc_ip = vc_ip
        self.vc_password = vc_password
        self.vc_port = vc_port
        self.vc_username = vc_username
        self.vc_version = vc_version
        VapiStruct.__init__(self)


SourceNsxApiEndpoint._set_binding_type(type.StructType(
    'com.vmware.nsx.model.source_nsx_api_endpoint', {
        'auth_token': type.OptionalType(type.StringType()),
        'ip': type.OptionalType(type.StringType()),
        'nsx_password': type.OptionalType(type.StringType()),
        'nsx_syncrole': type.OptionalType(type.StringType()),
        'nsx_username': type.OptionalType(type.StringType()),
        'nsx_version': type.OptionalType(type.StringType()),
        'vc_ip': type.OptionalType(type.StringType()),
        'vc_password': type.OptionalType(type.StringType()),
        'vc_port': type.OptionalType(type.IntegerType()),
        'vc_username': type.OptionalType(type.StringType()),
        'vc_version': type.OptionalType(type.StringType()),
    },
    SourceNsxApiEndpoint,
    False,
    None))



class SpoofGuardSwitchingProfile(VapiStruct):
    """
    SpoofGuard configuration

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "SpoofGuardSwitchingProfile"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    WHITE_LIST_PROVIDERS_LPORT_BINDINGS = "LPORT_BINDINGS"
    """


    """
    WHITE_LIST_PROVIDERS_LSWITCH_BINDINGS = "LSWITCH_BINDINGS"
    """


    """



    _canonical_to_pep_names = {
                            'white_list_providers': 'white_list_providers',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'required_capabilities': 'required_capabilities',
                            }

    def __init__(self,
                 white_list_providers=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='SpoofGuardSwitchingProfile',
                 tags=None,
                 required_capabilities=None,
                ):
        """
        :type  white_list_providers: :class:`list` of :class:`str` or ``None``
        :param white_list_providers: Possible values are: 
            
            *
              :attr:`SpoofGuardSwitchingProfile.WHITE_LIST_PROVIDERS_LPORT_BINDINGS`
            *
              :attr:`SpoofGuardSwitchingProfile.WHITE_LIST_PROVIDERS_LSWITCH_BINDINGS`
            
             List of providers for white listed address bindings.
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: 
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  required_capabilities: :class:`list` of :class:`str` or ``None``
        :param required_capabilities: 
        """
        self.white_list_providers = white_list_providers
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        self.required_capabilities = required_capabilities
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

SpoofGuardSwitchingProfile._set_binding_type(type.StructType(
    'com.vmware.nsx.model.spoof_guard_switching_profile', {
        'white_list_providers': type.OptionalType(type.ListType(type.StringType())),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'required_capabilities': type.OptionalType(type.ListType(type.StringType())),
    },
    SpoofGuardSwitchingProfile,
    False,
    None))



class SshKeyBaseProperties(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'label': 'label',
                            'password': 'password',
                            }

    def __init__(self,
                 label=None,
                 password=None,
                ):
        """
        :type  label: :class:`str` or ``None``
        :param label: SSH key label (used to identify the key)
        :type  password: :class:`str` or ``None``
        :param password: Current password for user (required for users root and admin)
        """
        self.label = label
        self.password = password
        VapiStruct.__init__(self)


SshKeyBaseProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.ssh_key_base_properties', {
        'label': type.OptionalType(type.StringType()),
        'password': type.OptionalType(type.StringType()),
    },
    SshKeyBaseProperties,
    False,
    None))



class SshKeyProperties(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'label': 'label',
                            'password': 'password',
                            'type': 'type',
                            'value': 'value',
                            }

    def __init__(self,
                 label=None,
                 password=None,
                 type=None,
                 value=None,
                ):
        """
        :type  label: :class:`str` or ``None``
        :param label: SSH key label (used to identify the key)
        :type  password: :class:`str` or ``None``
        :param password: Current password for user (required for users root and admin)
        :type  type: :class:`str` or ``None``
        :param type: SSH key type
        :type  value: :class:`str` or ``None``
        :param value: SSH key value
        """
        self.label = label
        self.password = password
        self.type = type
        self.value = value
        VapiStruct.__init__(self)


SshKeyProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.ssh_key_properties', {
        'label': type.OptionalType(type.StringType()),
        'password': type.OptionalType(type.StringType()),
        'type': type.OptionalType(type.StringType()),
        'value': type.OptionalType(type.StringType()),
    },
    SshKeyProperties,
    False,
    None))



class SshKeyPropertiesListResult(VapiStruct):
    """
    SSH key properties query results

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`SshKeyProperties` or ``None``
        :param results: SSH key properties query results
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


SshKeyPropertiesListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.ssh_key_properties_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'SshKeyProperties'))),
    },
    SshKeyPropertiesListResult,
    False,
    None))



class SshServiceProperties(VapiStruct):
    """
    SSH Service properties

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'start_on_boot': 'start_on_boot',
                            }

    def __init__(self,
                 start_on_boot=None,
                ):
        """
        :type  start_on_boot: :class:`bool` or ``None``
        :param start_on_boot: Start service when system boots
        """
        self.start_on_boot = start_on_boot
        VapiStruct.__init__(self)


SshServiceProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.ssh_service_properties', {
        'start_on_boot': type.OptionalType(type.BooleanType()),
    },
    SshServiceProperties,
    False,
    None))



class StandardHostSwitch(VapiStruct):
    """
    Standard host switch specification

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    HOST_SWITCH_MODE_STANDARD = "STANDARD"
    """


    """
    HOST_SWITCH_MODE_ENS = "ENS"
    """


    """
    HOST_SWITCH_MODE_ENS_INTERRUPT = "ENS_INTERRUPT"
    """


    """
    HOST_SWITCH_TYPE_NVDS = "NVDS"
    """


    """
    HOST_SWITCH_TYPE_VDS = "VDS"
    """


    """



    _canonical_to_pep_names = {
                            'cpu_config': 'cpu_config',
                            'host_switch_id': 'host_switch_id',
                            'host_switch_mode': 'host_switch_mode',
                            'host_switch_name': 'host_switch_name',
                            'host_switch_profile_ids': 'host_switch_profile_ids',
                            'host_switch_type': 'host_switch_type',
                            'ip_assignment_spec': 'ip_assignment_spec',
                            'is_migrate_pnics': 'is_migrate_pnics',
                            'pnics': 'pnics',
                            'pnics_uninstall_migration': 'pnics_uninstall_migration',
                            'transport_zone_endpoints': 'transport_zone_endpoints',
                            'uplinks': 'uplinks',
                            'vmk_install_migration': 'vmk_install_migration',
                            'vmk_uninstall_migration': 'vmk_uninstall_migration',
                            }

    def __init__(self,
                 cpu_config=None,
                 host_switch_id=None,
                 host_switch_mode=None,
                 host_switch_name=None,
                 host_switch_profile_ids=None,
                 host_switch_type=None,
                 ip_assignment_spec=None,
                 is_migrate_pnics=None,
                 pnics=None,
                 pnics_uninstall_migration=None,
                 transport_zone_endpoints=None,
                 uplinks=None,
                 vmk_install_migration=None,
                 vmk_uninstall_migration=None,
                ):
        """
        :type  cpu_config: :class:`list` of :class:`CpuCoreConfigForEnhancedNetworkingStackSwitch` or ``None``
        :param cpu_config: CPU configuration specifies number of Logical cpu cores (Lcores)
            per Non Uniform Memory Access (NUMA) node dedicated to Enhanced
            Networking Stack enabled HostSwitch to get the best performance.
        :type  host_switch_id: :class:`str` or ``None``
        :param host_switch_id: This field is writable only in case of VDS type HostSwitch and
            system generated for NVDS type. For VDS type host switch, This
            field is used to lookup a VDS from corresponding Compute Manager
            and then can be configured for logical networking. For NVDS type
            host switch, This field is system generated and if provided will be
            overwritten.
        :type  host_switch_mode: :class:`str` or ``None``
        :param host_switch_mode: Possible values are: 
            
            * :attr:`StandardHostSwitch.HOST_SWITCH_MODE_STANDARD`
            * :attr:`StandardHostSwitch.HOST_SWITCH_MODE_ENS`
            * :attr:`StandardHostSwitch.HOST_SWITCH_MODE_ENS_INTERRUPT`
            
            STANDARD - This mode applies to all the hypervisors. ENS - This is
            the Enhanced Data Path switch mode. This mode provides accelerated
            networking performances but also introduces additional
            prerequisites. In order to benefit from this mode, workloads will
            be need to be compiled with DPDK and will use VMXNET3 for their
            vNIC. This mode is only available on ESX hypervisor (6.7 and above,
            recommended 6.7 U2 and above) and unavailable on KVM, EDGE and
            Public Cloud Gateway. Not all NSX features are available in this
            mode, please consult the documentation. ENS_INTERRUPT - This is an
            interrupt driven variant of the Enhanced Data Path mode. Please,
            consult your account representative for applicability. This mode is
            available only on ESX hypervisor (7.0 and above). If this property
            is specified, transport_zone_endpoints must be specified at
            StandardHostSwitch level.
        :type  host_switch_name: :class:`str` or ``None``
        :param host_switch_name: This field is writable only in case of NVDS type HostSwitch and
            system generated for VDS type. For NVDS type host switch, If this
            name is unset or empty then the default host switch name will be
            used. The name must be unique among all host switches specified in
            a given transport node; unset name, empty name and the default host
            switch name are considered the same in terms of uniqueness. For VDS
            type host switch, Manager fetches VDS name from corresponding
            Compute Manager and populates this field. If VDS name is given
            (correct or incorrect) it is ignored and overwritten with correct
            one.
        :type  host_switch_profile_ids: :class:`list` of :class:`HostSwitchProfileTypeIdEntry` or ``None``
        :param host_switch_profile_ids: Host switch profiles bound to this host switch. If a profile ID is
            not provided for any HostSwitchProfileType that is supported by the
            transport node, the corresponding default profile will be bound to
            the host switch.
        :type  host_switch_type: :class:`str` or ``None``
        :param host_switch_type: Possible values are: 
            
            * :attr:`StandardHostSwitch.HOST_SWITCH_TYPE_NVDS`
            * :attr:`StandardHostSwitch.HOST_SWITCH_TYPE_VDS`
            
            VDS represents VMware vSphere Distributed Switch from vSphere that
            is used as HostSwitch through TransportNode or TransportNodeProfile
            configuration. When VDS is used as a HostSwitch, Hosts have to be
            added to VDS from vSphere and VDS instance is created on Hosts. To
            configure NSX on such hosts, you can use this VDS as a HostSwitch
            from NSX manager. vCenter has the ownership of MTU, LAG, NIOC and
            LLDP configuration of such VDS backed HostSwitch. Remaining
            configuration (e.g. UplinkHostswitchProfile) will be managed by
            NSX. NVDS represents NSX Virtual Switch which is NSX native
            HostSwitch. All configurations of NVDS will be managed by NSX.
        :type  ip_assignment_spec: :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param ip_assignment_spec: IPs can come from either a static IP pool or an explicitly
            specified IP list or DHCP. In case a list of IP is specified, the
            number of IPs provided should be sufficient as per teaming policy
            associated with host switch uplink profile.
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`IpAssignmentSpec`. When methods return a value of this
            class as a return value, the attribute will contain all the
            attributes defined in :class:`IpAssignmentSpec`.
        :type  is_migrate_pnics: :class:`bool` or ``None``
        :param is_migrate_pnics: If the pnics specified in the pnics field are used by a single
            Vsphere Standard Switch or DVS, then migrate the pnics to N-VDS. If
            any two pnics are not used by the same Vsphere Standard Switch or
            DVS, it is not supported. In such cases, please migrate them in
            multiple steps, one Vsphere Standard Switch or DVS at a time.
        :type  pnics: :class:`list` of :class:`Pnic` or ``None``
        :param pnics: Pnic can be specified only for NVDS type of HostSwitch.
        :type  pnics_uninstall_migration: :class:`list` of :class:`Pnic` or ``None``
        :param pnics_uninstall_migration: This is only supported for NVDS type of host switch. If this is
            specified for VDS type of host switch, an error will be returned to
            user. The pnics to be migrated out to a non N-VDS switch during
            transport node deletion.
        :type  transport_zone_endpoints: :class:`list` of :class:`TransportZoneEndPoint` or ``None``
        :param transport_zone_endpoints: List of TransportZones that are to be associated with specified
            host switch. If this property is specified, host_switch_mode at
            StandardHostSwitch level must be specified.
        :type  uplinks: :class:`list` of :class:`VdsUplink` or ``None``
        :param uplinks: If VDS is used as a HostSwitch this attribute must be specified.
            You can associate uplinks from UplinkHostSwitchProfile to either
            VDS uplink or LAG. VDS uplink or LAG will inherit the global VDS
            level teaming policy from vSphere. NSX managed uplink or LAG will
            have NSX teaming policy configured through UplinkHostSwitchProfile.
        :type  vmk_install_migration: :class:`list` of :class:`VmknicNetwork` or ``None``
        :param vmk_install_migration: This is only supported for NVDS type of host switch. If this is
            specified for VDS type of host switch, an error will be returned to
            user. The vmk interfaces and the associated logical switches on the
            host switch. The state of this field is realized on the transport
            node during creation and update.
        :type  vmk_uninstall_migration: :class:`list` of :class:`VmknicNetwork` or ``None``
        :param vmk_uninstall_migration: This is only supported for NVDS type of host switch. If this is
            specified for VDS type of host switch, an error will be returned to
            user. The vmk interfaces and the associated portgroups on the
            VSS/DVS. This field is realized on the host during transport node
            deletion or NSX uninstallation to specify the destination for all
            vmks on N-VDS switches.
        """
        self.cpu_config = cpu_config
        self.host_switch_id = host_switch_id
        self.host_switch_mode = host_switch_mode
        self.host_switch_name = host_switch_name
        self.host_switch_profile_ids = host_switch_profile_ids
        self.host_switch_type = host_switch_type
        self.ip_assignment_spec = ip_assignment_spec
        self.is_migrate_pnics = is_migrate_pnics
        self.pnics = pnics
        self.pnics_uninstall_migration = pnics_uninstall_migration
        self.transport_zone_endpoints = transport_zone_endpoints
        self.uplinks = uplinks
        self.vmk_install_migration = vmk_install_migration
        self.vmk_uninstall_migration = vmk_uninstall_migration
        VapiStruct.__init__(self)


StandardHostSwitch._set_binding_type(type.StructType(
    'com.vmware.nsx.model.standard_host_switch', {
        'cpu_config': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'CpuCoreConfigForEnhancedNetworkingStackSwitch'))),
        'host_switch_id': type.OptionalType(type.StringType()),
        'host_switch_mode': type.OptionalType(type.StringType()),
        'host_switch_name': type.OptionalType(type.StringType()),
        'host_switch_profile_ids': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'HostSwitchProfileTypeIdEntry'))),
        'host_switch_type': type.OptionalType(type.StringType()),
        'ip_assignment_spec': type.OptionalType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'IpAssignmentSpec')])),
        'is_migrate_pnics': type.OptionalType(type.BooleanType()),
        'pnics': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Pnic'))),
        'pnics_uninstall_migration': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Pnic'))),
        'transport_zone_endpoints': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'TransportZoneEndPoint'))),
        'uplinks': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'VdsUplink'))),
        'vmk_install_migration': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'VmknicNetwork'))),
        'vmk_uninstall_migration': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'VmknicNetwork'))),
    },
    StandardHostSwitch,
    False,
    None))



class StandardHostSwitchSpec(VapiStruct):
    """
    Standard host switch specification is used for NSX configured transport
    node.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "StandardHostSwitchSpec"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'host_switches': 'host_switches',
                            'resource_type': 'resource_type',
                            }

    def __init__(self,
                 host_switches=None,
                 resource_type='StandardHostSwitchSpec',
                ):
        """
        :type  host_switches: :class:`list` of :class:`StandardHostSwitch` or ``None``
        :param host_switches: Transport Node host switches
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`HostSwitchSpec.RESOURCE_TYPE_STANDARDHOSTSWITCHSPEC`
            * :attr:`HostSwitchSpec.RESOURCE_TYPE_PRECONFIGUREDHOSTSWITCHSPEC`
        """
        self.host_switches = host_switches
        self._resource_type = resource_type
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

StandardHostSwitchSpec._set_binding_type(type.StructType(
    'com.vmware.nsx.model.standard_host_switch_spec', {
        'host_switches': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'StandardHostSwitch'))),
        'resource_type': type.StringType(),
    },
    StandardHostSwitchSpec,
    False,
    None))



class StandbyRelocationConfig(VapiStruct):
    """
    Standby service contexts relocation setting

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'standby_relocation_threshold': 'standby_relocation_threshold',
                            }

    def __init__(self,
                 standby_relocation_threshold=None,
                ):
        """
        :type  standby_relocation_threshold: :class:`long` or ``None``
        :param standby_relocation_threshold: The time interval (in minutes) to wait before starting the standby
            service context relocation process. format: int64
        """
        self.standby_relocation_threshold = standby_relocation_threshold
        VapiStruct.__init__(self)


StandbyRelocationConfig._set_binding_type(type.StructType(
    'com.vmware.nsx.model.standby_relocation_config', {
        'standby_relocation_threshold': type.OptionalType(type.IntegerType()),
    },
    StandbyRelocationConfig,
    False,
    None))



class StatItem(VapiStruct):
    """
    Displayed as a single number. It can be used to show the characteristics of
    entities such as Logical Switches, Firewall Rules, and so on. For example,
    number of logical switches and their admin states.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'drilldown_id': 'drilldown_id',
                            'tooltip': 'tooltip',
                            'total': 'total',
                            'value': 'value',
                            }

    def __init__(self,
                 drilldown_id=None,
                 tooltip=None,
                 total=None,
                 value=None,
                ):
        """
        :type  drilldown_id: :class:`str` or ``None``
        :param drilldown_id: Id of drilldown widget, if any. Id should be a valid id of an
            existing widget.
        :type  tooltip: :class:`list` of :class:`Tooltip` or ``None``
        :param tooltip: Multi-line text to be shown on tooltip while hovering over the
            stat.
        :type  total: :class:`str` or ``None``
        :param total: If expression for total is specified, it evaluates it. Total can be
            omitted if not needed to be shown.
        :type  value: :class:`str` or ``None``
        :param value: Expression for stat to be displayed.
        """
        self.drilldown_id = drilldown_id
        self.tooltip = tooltip
        self.total = total
        self.value = value
        VapiStruct.__init__(self)


StatItem._set_binding_type(type.StructType(
    'com.vmware.nsx.model.stat_item', {
        'drilldown_id': type.OptionalType(type.StringType()),
        'tooltip': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tooltip'))),
        'total': type.OptionalType(type.StringType()),
        'value': type.OptionalType(type.StringType()),
    },
    StatItem,
    False,
    None))



class StaticFilter(VapiStruct):
    """
    Static filters

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'display_name': 'display_name',
                            'value': 'value',
                            }

    def __init__(self,
                 display_name=None,
                 value=None,
                ):
        """
        :type  display_name: :class:`str` or ``None``
        :param display_name: display name to be shown in the drop down for static filter.
        :type  value: :class:`str` or ``None``
        :param value: Value of static filter inside dropdown filter.
        """
        self.display_name = display_name
        self.value = value
        VapiStruct.__init__(self)


StaticFilter._set_binding_type(type.StructType(
    'com.vmware.nsx.model.static_filter', {
        'display_name': type.OptionalType(type.StringType()),
        'value': type.OptionalType(type.StringType()),
    },
    StaticFilter,
    False,
    None))



class StaticHopBfdPeer(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'bfd_config': 'bfd_config',
                            'enabled': 'enabled',
                            'peer_ip_address': 'peer_ip_address',
                            'source_addresses': 'source_addresses',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 bfd_config=None,
                 enabled=None,
                 peer_ip_address=None,
                 source_addresses=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  bfd_config: :class:`BfdConfigParameters` or ``None``
        :param bfd_config: If not specified then BFD peer will inherit configuration from the
            BFD global config.
        :type  enabled: :class:`bool` or ``None``
        :param enabled: Indicate BFD peer is enabled or disabled. Default is true.
        :type  peer_ip_address: :class:`str` or ``None``
        :param peer_ip_address: IP address of BFD peer. This should be same as next hop IP address.
            format: ip
        :type  source_addresses: :class:`list` of :class:`str` or ``None``
        :param source_addresses: BFD peers will be created from all these source addresses to this
            neighbour. format: ip
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.bfd_config = bfd_config
        self.enabled = enabled
        self.peer_ip_address = peer_ip_address
        self.source_addresses = source_addresses
        VapiStruct.__init__(self)


StaticHopBfdPeer._set_binding_type(type.StructType(
    'com.vmware.nsx.model.static_hop_bfd_peer', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'bfd_config': type.OptionalType(type.ReferenceType(__name__, 'BfdConfigParameters')),
        'enabled': type.OptionalType(type.BooleanType()),
        'peer_ip_address': type.OptionalType(type.StringType()),
        'source_addresses': type.OptionalType(type.ListType(type.StringType())),
    },
    StaticHopBfdPeer,
    False,
    None))



class StaticHopBfdPeerListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`StaticHopBfdPeer` or ``None``
        :param results: static hop BFD peer list results
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


StaticHopBfdPeerListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.static_hop_bfd_peer_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'StaticHopBfdPeer'))),
    },
    StaticHopBfdPeerListResult,
    False,
    None))



class StaticIpListSpec(VapiStruct):
    """
    IP assignment specification for Static IP List.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "StaticIpListSpec"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'default_gateway': 'default_gateway',
                            'ip_list': 'ip_list',
                            'subnet_mask': 'subnet_mask',
                            'resource_type': 'resource_type',
                            }

    def __init__(self,
                 default_gateway=None,
                 ip_list=None,
                 subnet_mask=None,
                 resource_type='StaticIpListSpec',
                ):
        """
        :type  default_gateway: :class:`str` or ``None``
        :param default_gateway: Gateway IP format: ip
        :type  ip_list: :class:`list` of :class:`str` or ``None``
        :param ip_list: List of IPs for transport node host switch virtual tunnel endpoints
            format: ip
        :type  subnet_mask: :class:`str` or ``None``
        :param subnet_mask: Subnet mask format: ip
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`IpAssignmentSpec.RESOURCE_TYPE_STATICIPPOOLSPEC`
            * :attr:`IpAssignmentSpec.RESOURCE_TYPE_STATICIPLISTSPEC`
            * :attr:`IpAssignmentSpec.RESOURCE_TYPE_ASSIGNEDBYDHCP`
            * :attr:`IpAssignmentSpec.RESOURCE_TYPE_STATICIPMACLISTSPEC`
        """
        self.default_gateway = default_gateway
        self.ip_list = ip_list
        self.subnet_mask = subnet_mask
        self._resource_type = resource_type
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

StaticIpListSpec._set_binding_type(type.StructType(
    'com.vmware.nsx.model.static_ip_list_spec', {
        'default_gateway': type.OptionalType(type.StringType()),
        'ip_list': type.OptionalType(type.ListType(type.StringType())),
        'subnet_mask': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
    },
    StaticIpListSpec,
    False,
    None))



class StaticIpMacListSpec(VapiStruct):
    """
    IP and MAC assignment specification for Static IP List.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "StaticIpMacListSpec"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'default_gateway': 'default_gateway',
                            'ip_mac_list': 'ip_mac_list',
                            'subnet_mask': 'subnet_mask',
                            'resource_type': 'resource_type',
                            }

    def __init__(self,
                 default_gateway=None,
                 ip_mac_list=None,
                 subnet_mask=None,
                 resource_type='StaticIpMacListSpec',
                ):
        """
        :type  default_gateway: :class:`str` or ``None``
        :param default_gateway: Gateway IP format: ip
        :type  ip_mac_list: :class:`list` of :class:`IpMacPair` or ``None``
        :param ip_mac_list: List of IPs and MACs for transport node host switch virtual tunnel
            endpoints
        :type  subnet_mask: :class:`str` or ``None``
        :param subnet_mask: Subnet mask format: ip
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`IpAssignmentSpec.RESOURCE_TYPE_STATICIPPOOLSPEC`
            * :attr:`IpAssignmentSpec.RESOURCE_TYPE_STATICIPLISTSPEC`
            * :attr:`IpAssignmentSpec.RESOURCE_TYPE_ASSIGNEDBYDHCP`
            * :attr:`IpAssignmentSpec.RESOURCE_TYPE_STATICIPMACLISTSPEC`
        """
        self.default_gateway = default_gateway
        self.ip_mac_list = ip_mac_list
        self.subnet_mask = subnet_mask
        self._resource_type = resource_type
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

StaticIpMacListSpec._set_binding_type(type.StructType(
    'com.vmware.nsx.model.static_ip_mac_list_spec', {
        'default_gateway': type.OptionalType(type.StringType()),
        'ip_mac_list': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IpMacPair'))),
        'subnet_mask': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
    },
    StaticIpMacListSpec,
    False,
    None))



class StaticIpPoolSpec(VapiStruct):
    """
    IP assignment specification for Static IP Pool.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "StaticIpPoolSpec"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'ip_pool_id': 'ip_pool_id',
                            'resource_type': 'resource_type',
                            }

    def __init__(self,
                 ip_pool_id=None,
                 resource_type='StaticIpPoolSpec',
                ):
        """
        :type  ip_pool_id: :class:`str` or ``None``
        :param ip_pool_id: 
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`IpAssignmentSpec.RESOURCE_TYPE_STATICIPPOOLSPEC`
            * :attr:`IpAssignmentSpec.RESOURCE_TYPE_STATICIPLISTSPEC`
            * :attr:`IpAssignmentSpec.RESOURCE_TYPE_ASSIGNEDBYDHCP`
            * :attr:`IpAssignmentSpec.RESOURCE_TYPE_STATICIPMACLISTSPEC`
        """
        self.ip_pool_id = ip_pool_id
        self._resource_type = resource_type
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

StaticIpPoolSpec._set_binding_type(type.StructType(
    'com.vmware.nsx.model.static_ip_pool_spec', {
        'ip_pool_id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
    },
    StaticIpPoolSpec,
    False,
    None))



class StaticRoute(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'logical_router_id': 'logical_router_id',
                            'network': 'network',
                            'next_hops': 'next_hops',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 logical_router_id=None,
                 network=None,
                 next_hops=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  logical_router_id: :class:`str` or ``None``
        :param logical_router_id: Logical router id
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  network: :class:`str` or ``None``
        :param network: CIDR format: ip-cidr-block
        :type  next_hops: :class:`list` of :class:`StaticRouteNextHop` or ``None``
        :param next_hops: Next Hops
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.logical_router_id = logical_router_id
        self.network = network
        self.next_hops = next_hops
        VapiStruct.__init__(self)


StaticRoute._set_binding_type(type.StructType(
    'com.vmware.nsx.model.static_route', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'logical_router_id': type.OptionalType(type.StringType()),
        'network': type.OptionalType(type.StringType()),
        'next_hops': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'StaticRouteNextHop'))),
    },
    StaticRoute,
    False,
    None))



class StaticRouteListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`StaticRoute` or ``None``
        :param results: Paginated list of static routes
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


StaticRouteListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.static_route_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'StaticRoute'))),
    },
    StaticRouteListResult,
    False,
    None))



class StaticRouteNextHop(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    BLACKHOLE_ACTION_DISCARD = "DISCARD"
    """


    """



    _canonical_to_pep_names = {
                            'administrative_distance': 'administrative_distance',
                            'bfd_enabled': 'bfd_enabled',
                            'blackhole_action': 'blackhole_action',
                            'ip_address': 'ip_address',
                            'logical_router_port_id': 'logical_router_port_id',
                            }

    def __init__(self,
                 administrative_distance=None,
                 bfd_enabled=None,
                 blackhole_action=None,
                 ip_address=None,
                 logical_router_port_id=None,
                ):
        """
        :type  administrative_distance: :class:`long` or ``None``
        :param administrative_distance: Administrative Distance for the next hop IP format: int64
        :type  bfd_enabled: :class:`bool` or ``None``
        :param bfd_enabled: Status of bfd for this next hop where bfd_enabled = true indicate
            bfd is enabled for this next hop and bfd_enabled = false indicate
            bfd peer is disabled or not configured for this next hop.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  blackhole_action: :class:`str` or ``None``
        :param blackhole_action: Possible values are: 
            
            * :attr:`StaticRouteNextHop.BLACKHOLE_ACTION_DISCARD`
            
             Action to be taken on matching packets for NULL routes.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  ip_address: :class:`str` or ``None``
        :param ip_address: Next Hop IP format: ip
        :type  logical_router_port_id: :class:`ResourceReference` or ``None``
        :param logical_router_port_id: Reference of logical router port to be used for next hop
        """
        self.administrative_distance = administrative_distance
        self.bfd_enabled = bfd_enabled
        self.blackhole_action = blackhole_action
        self.ip_address = ip_address
        self.logical_router_port_id = logical_router_port_id
        VapiStruct.__init__(self)


StaticRouteNextHop._set_binding_type(type.StructType(
    'com.vmware.nsx.model.static_route_next_hop', {
        'administrative_distance': type.OptionalType(type.IntegerType()),
        'bfd_enabled': type.OptionalType(type.BooleanType()),
        'blackhole_action': type.OptionalType(type.StringType()),
        'ip_address': type.OptionalType(type.StringType()),
        'logical_router_port_id': type.OptionalType(type.ReferenceType(__name__, 'ResourceReference')),
    },
    StaticRouteNextHop,
    False,
    None))



class StatsConfiguration(VapiStruct):
    """
    Represents configuration of a statistic for an entity. Example, number of
    logical switches and their admin states.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "StatsConfiguration"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    SUB_TYPE_COMPACT = "COMPACT"
    """


    """



    _canonical_to_pep_names = {
                            'label': 'label',
                            'navigation': 'navigation',
                            'sections': 'sections',
                            'stat': 'stat',
                            'sub_type': 'sub_type',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'datasources': 'datasources',
                            'default_filter_value': 'default_filter_value',
                            'drilldown_id': 'drilldown_id',
                            'filter': 'filter',
                            'filter_value_required': 'filter_value_required',
                            'footer': 'footer',
                            'icons': 'icons',
                            'is_drilldown': 'is_drilldown',
                            'legend': 'legend',
                            'shared': 'shared',
                            'span': 'span',
                            'weight': 'weight',
                            }

    def __init__(self,
                 label=None,
                 navigation=None,
                 sections=None,
                 stat=None,
                 sub_type=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='StatsConfiguration',
                 tags=None,
                 datasources=None,
                 default_filter_value=None,
                 drilldown_id=None,
                 filter=None,
                 filter_value_required=None,
                 footer=None,
                 icons=None,
                 is_drilldown=None,
                 legend=None,
                 shared=None,
                 span=None,
                 weight=None,
                ):
        """
        :type  label: :class:`Label` or ``None``
        :param label: Displayed at the sections, by default. It labels the entities of
            sections. If label is not provided, the sections are not labelled.
        :type  navigation: :class:`str` or ``None``
        :param navigation: Hyperlink of the specified UI page that provides details.
        :type  sections: :class:`list` of :class:`DonutSection` or ``None``
        :param sections: Sections
        :type  stat: :class:`StatItem` or ``None``
        :param stat: Expression that fetches statistic. It can be used to show the
            characteristics of entities such as Logical Switches, Firewall
            Rules, and so on. For example, number of logical switches and their
            admin states. If stat is not provided, then it will not be
            displayed.
        :type  sub_type: :class:`str` or ``None``
        :param sub_type: Possible values are: 
            
            * :attr:`StatsConfiguration.SUB_TYPE_COMPACT`
            
            A sub-type of StatsConfiguration. If sub-type is not specified the
            parent type is rendered. The COMPACT sub_type, conserves the space
            for the widget. The statistic is placed on the right side on top of
            the status bar and the title of the widget is placed on the left
            side on the top of the status bar. The COMPACT style aligns itself
            horizontally as per the width of the container. If multiple widgets
            are placed insided the container then the widgets are placed one
            below the other to conserve the space.
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Title of the widget. If display_name is omitted, the widget will be
            shown without a title.
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_LABELVALUECONFIGURATION`
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_DONUTCONFIGURATION`
            *
              :attr:`WidgetConfiguration.RESOURCE_TYPE_MULTIWIDGETCONFIGURATION`
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_CONTAINERCONFIGURATION`
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_STATSCONFIGURATION`
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_GRIDCONFIGURATION`
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_GRAPHCONFIGURATION`
            *
              :attr:`WidgetConfiguration.RESOURCE_TYPE_CUSTOMWIDGETCONFIGURATION`
            *
              :attr:`WidgetConfiguration.RESOURCE_TYPE_DROPDOWNFILTERWIDGETCONFIGURATION`
            
            Supported visualization types are LabelValueConfiguration,
            DonutConfiguration, GridConfiguration, StatsConfiguration,
            MultiWidgetConfiguration, GraphConfiguration,
            ContainerConfiguration, CustomWidgetConfiguration and
            DropdownFilterWidgetConfiguration.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  datasources: :class:`list` of :class:`Datasource` or ``None``
        :param datasources: The 'datasources' represent the sources from which data will be
            fetched. Currently, only NSX-API is supported as a 'default'
            datasource. An example of specifying 'default' datasource along
            with the urls to fetch data from is given at 'example_request'
            section of 'CreateWidgetConfiguration' API.
        :type  default_filter_value: :class:`list` of :class:`DefaultFilterValue` or ``None``
        :param default_filter_value: Default filter values to be passed to datasources. This will be
            used when the report is requested without filter values.
        :type  drilldown_id: :class:`str` or ``None``
        :param drilldown_id: Id of drilldown widget, if any. Id should be a valid id of an
            existing widget. A widget is considered as drilldown widget when it
            is associated with any other widget and provides more detailed
            information about any data item from the parent widget.
        :type  filter: :class:`str` or ``None``
        :param filter: Id of filter widget for subscription, if any. Id should be a valid
            id of an existing filter widget. Filter widget should be from the
            same view. Datasource URLs should have placeholder values equal to
            filter alias to accept the filter value on filter change.
        :type  filter_value_required: :class:`bool` or ``None``
        :param filter_value_required: Flag to indicate that widget will continue to work without filter
            value. If this flag is set to false then default_filter_value is
            manadatory.
        :type  footer: :class:`Footer` or ``None``
        :param footer: 
        :type  icons: :class:`list` of :class:`Icon` or ``None``
        :param icons: Icons to be applied at dashboard for widgets and UI elements.
        :type  is_drilldown: :class:`bool` or ``None``
        :param is_drilldown: Set to true if this widget should be used as a drilldown.
        :type  legend: :class:`Legend` or ``None``
        :param legend: Legend to be displayed. If legend is not needed, do not include it.
        :type  shared: :class:`bool` or ``None``
        :param shared: Please use the property 'shared' of View instead of this. The
            widgets of a shared view are visible to other users.
        :type  span: :class:`long` or ``None``
        :param span: Represents the horizontal span of the widget / container. format:
            int32
        :type  weight: :class:`long` or ``None``
        :param weight: Specify relavite weight in WidgetItem for placement in a view.
            Please see WidgetItem for details. format: int32
        """
        self.label = label
        self.navigation = navigation
        self.sections = sections
        self.stat = stat
        self.sub_type = sub_type
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        self.datasources = datasources
        self.default_filter_value = default_filter_value
        self.drilldown_id = drilldown_id
        self.filter = filter
        self.filter_value_required = filter_value_required
        self.footer = footer
        self.icons = icons
        self.is_drilldown = is_drilldown
        self.legend = legend
        self.shared = shared
        self.span = span
        self.weight = weight
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

StatsConfiguration._set_binding_type(type.StructType(
    'com.vmware.nsx.model.stats_configuration', {
        'label': type.OptionalType(type.ReferenceType(__name__, 'Label')),
        'navigation': type.OptionalType(type.StringType()),
        'sections': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'DonutSection'))),
        'stat': type.OptionalType(type.ReferenceType(__name__, 'StatItem')),
        'sub_type': type.OptionalType(type.StringType()),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'datasources': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Datasource'))),
        'default_filter_value': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'DefaultFilterValue'))),
        'drilldown_id': type.OptionalType(type.StringType()),
        'filter': type.OptionalType(type.StringType()),
        'filter_value_required': type.OptionalType(type.BooleanType()),
        'footer': type.OptionalType(type.ReferenceType(__name__, 'Footer')),
        'icons': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Icon'))),
        'is_drilldown': type.OptionalType(type.BooleanType()),
        'legend': type.OptionalType(type.ReferenceType(__name__, 'Legend')),
        'shared': type.OptionalType(type.BooleanType()),
        'span': type.OptionalType(type.IntegerType()),
        'weight': type.OptionalType(type.IntegerType()),
    },
    StatsConfiguration,
    False,
    None))



class StatusCount(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATUS_UP = "UP"
    """


    """
    STATUS_DOWN = "DOWN"
    """


    """
    STATUS_DEGRADED = "DEGRADED"
    """


    """
    STATUS_UNKNOWN = "UNKNOWN"
    """


    """



    _canonical_to_pep_names = {
                            'degraded_count': 'degraded_count',
                            'down_count': 'down_count',
                            'status': 'status',
                            'up_count': 'up_count',
                            }

    def __init__(self,
                 degraded_count=None,
                 down_count=None,
                 status=None,
                 up_count=None,
                ):
        """
        :type  degraded_count: :class:`long` or ``None``
        :param degraded_count: Degraded count format: int32
        :type  down_count: :class:`long` or ``None``
        :param down_count: Down count format: int32
        :type  status: :class:`str` or ``None``
        :param status: Possible values are: 
            
            * :attr:`StatusCount.STATUS_UP`
            * :attr:`StatusCount.STATUS_DOWN`
            * :attr:`StatusCount.STATUS_DEGRADED`
            * :attr:`StatusCount.STATUS_UNKNOWN`
            
             Roll-up status
        :type  up_count: :class:`long` or ``None``
        :param up_count: Up count format: int32
        """
        self.degraded_count = degraded_count
        self.down_count = down_count
        self.status = status
        self.up_count = up_count
        VapiStruct.__init__(self)


StatusCount._set_binding_type(type.StructType(
    'com.vmware.nsx.model.status_count', {
        'degraded_count': type.OptionalType(type.IntegerType()),
        'down_count': type.OptionalType(type.IntegerType()),
        'status': type.OptionalType(type.StringType()),
        'up_count': type.OptionalType(type.IntegerType()),
    },
    StatusCount,
    False,
    None))



class StructuredData(VapiStruct):
    """
    Structured data entry in RFC5424 log format

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'audit': 'audit',
                            'comp': 'comp',
                            'ent_id': 'ent_id',
                            'ereq_id': 'ereq_id',
                            'error_code': 'error_code',
                            'level': 'level',
                            'req_id': 'req_id',
                            's2comp': 's2comp',
                            'security': 'security',
                            'subcomp': 'subcomp',
                            'username': 'username',
                            }

    def __init__(self,
                 audit=None,
                 comp=None,
                 ent_id=None,
                 ereq_id=None,
                 error_code=None,
                 level=None,
                 req_id=None,
                 s2comp=None,
                 security=None,
                 subcomp=None,
                 username=None,
                ):
        """
        :type  audit: :class:`str` or ``None``
        :param audit: Audit flag of the log
        :type  comp: :class:`str` or ``None``
        :param comp: Component value of the log
        :type  ent_id: :class:`str` or ``None``
        :param ent_id: Entity Id value of the log
        :type  ereq_id: :class:`str` or ``None``
        :param ereq_id: External request Id value of the log
        :type  error_code: :class:`str` or ``None``
        :param error_code: Error Code value of the log
        :type  level: :class:`str` or ``None``
        :param level: Level value of the log
        :type  req_id: :class:`str` or ``None``
        :param req_id: Request Id value of the log
        :type  s2comp: :class:`str` or ``None``
        :param s2comp: Sub-subcomponent value of the log
        :type  security: :class:`str` or ``None``
        :param security: Security flag of the log
        :type  subcomp: :class:`str` or ``None``
        :param subcomp: Subcomponent value of the log
        :type  username: :class:`str` or ``None``
        :param username: Username value of the log
        """
        self.audit = audit
        self.comp = comp
        self.ent_id = ent_id
        self.ereq_id = ereq_id
        self.error_code = error_code
        self.level = level
        self.req_id = req_id
        self.s2comp = s2comp
        self.security = security
        self.subcomp = subcomp
        self.username = username
        VapiStruct.__init__(self)


StructuredData._set_binding_type(type.StructType(
    'com.vmware.nsx.model.structured_data', {
        'audit': type.OptionalType(type.StringType()),
        'comp': type.OptionalType(type.StringType()),
        'ent_id': type.OptionalType(type.StringType()),
        'ereq_id': type.OptionalType(type.StringType()),
        'error_code': type.OptionalType(type.StringType()),
        'level': type.OptionalType(type.StringType()),
        'req_id': type.OptionalType(type.StringType()),
        's2comp': type.OptionalType(type.StringType()),
        'security': type.OptionalType(type.StringType()),
        'subcomp': type.OptionalType(type.StringType()),
        'username': type.OptionalType(type.StringType()),
    },
    StructuredData,
    False,
    None))



class SubPool(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'remaining_credit_number': 'remaining_credit_number',
                            'sub_pool_type': 'sub_pool_type',
                            'usage_percentage': 'usage_percentage',
                            }

    def __init__(self,
                 remaining_credit_number=None,
                 sub_pool_type=None,
                 usage_percentage=None,
                ):
        """
        :type  remaining_credit_number: :class:`long` or ``None``
        :param remaining_credit_number: Credits remaining on the sub-pool that can be used to deploy
            services of corresponding sub-pool type. format: int32
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sub_pool_type: :class:`str` or ``None``
        :param sub_pool_type: Type of the sub-pool configured on edge node.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  usage_percentage: :class:`float` or ``None``
        :param usage_percentage: Percentage utlization of sub-pool based on the number of services
            configured and the hard limits, if any.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.remaining_credit_number = remaining_credit_number
        self.sub_pool_type = sub_pool_type
        self.usage_percentage = usage_percentage
        VapiStruct.__init__(self)


SubPool._set_binding_type(type.StructType(
    'com.vmware.nsx.model.sub_pool', {
        'remaining_credit_number': type.OptionalType(type.IntegerType()),
        'sub_pool_type': type.OptionalType(type.StringType()),
        'usage_percentage': type.OptionalType(type.DoubleType()),
    },
    SubPool,
    False,
    None))



class SuccessNodeSupportBundleResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'bundle_name': 'bundle_name',
                            'bundle_size': 'bundle_size',
                            'node_display_name': 'node_display_name',
                            'node_id': 'node_id',
                            'sha256_thumbprint': 'sha256_thumbprint',
                            }

    def __init__(self,
                 bundle_name=None,
                 bundle_size=None,
                 node_display_name=None,
                 node_id=None,
                 sha256_thumbprint=None,
                ):
        """
        :type  bundle_name: :class:`str` or ``None``
        :param bundle_name: Name of support bundle, e.g. nsx_NODETYPE_UUID_YYYYMMDD_HHMMSS.tgz
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  bundle_size: :class:`long` or ``None``
        :param bundle_size: Size of support bundle in bytes format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  node_display_name: :class:`str` or ``None``
        :param node_display_name: Display name of node
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  node_id: :class:`str` or ``None``
        :param node_id: UUID of node
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sha256_thumbprint: :class:`str` or ``None``
        :param sha256_thumbprint: File's SHA256 thumbprint
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.bundle_name = bundle_name
        self.bundle_size = bundle_size
        self.node_display_name = node_display_name
        self.node_id = node_id
        self.sha256_thumbprint = sha256_thumbprint
        VapiStruct.__init__(self)


SuccessNodeSupportBundleResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.success_node_support_bundle_result', {
        'bundle_name': type.OptionalType(type.StringType()),
        'bundle_size': type.OptionalType(type.IntegerType()),
        'node_display_name': type.OptionalType(type.StringType()),
        'node_id': type.OptionalType(type.StringType()),
        'sha256_thumbprint': type.OptionalType(type.StringType()),
    },
    SuccessNodeSupportBundleResult,
    False,
    None))



class SummaryMigrationFeedbackRequest(VapiStruct):
    """
    Minimal description of feedback requests.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'details': 'details',
                            'id': 'id',
                            'object_id': 'object_id',
                            'rejected': 'rejected',
                            'resolution': 'resolution',
                            'resolved': 'resolved',
                            'v_object_id': 'v_object_id',
                            'v_object_name': 'v_object_name',
                            }

    def __init__(self,
                 details=None,
                 id=None,
                 object_id=None,
                 rejected=None,
                 resolution=None,
                 resolved=None,
                 v_object_id=None,
                 v_object_name=None,
                ):
        """
        :type  details: :class:`str` or ``None``
        :param details: Details about this specific feedback request.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  id: :class:`str` or ``None``
        :param id: Identifier of the feedback request.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  object_id: :class:`str` or ``None``
        :param object_id: Identifier of the object for which feedback is requested.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  rejected: :class:`bool` or ``None``
        :param rejected: Indicates if previous response was invalid. Please provide a valid
            response.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  resolution: :class:`str` or ``None``
        :param resolution: If the feedback request was resolved earlier, provides details
            about the previous resolution.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  resolved: :class:`bool` or ``None``
        :param resolved: Indicates if a valid response already exist for this feedback
            request.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  v_object_id: :class:`str` or ``None``
        :param v_object_id: Identifier for this object in the source NSX endpoint.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  v_object_name: :class:`str` or ``None``
        :param v_object_name: Name of this object in the source NSX endpoint.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.details = details
        self.id = id
        self.object_id = object_id
        self.rejected = rejected
        self.resolution = resolution
        self.resolved = resolved
        self.v_object_id = v_object_id
        self.v_object_name = v_object_name
        VapiStruct.__init__(self)


SummaryMigrationFeedbackRequest._set_binding_type(type.StructType(
    'com.vmware.nsx.model.summary_migration_feedback_request', {
        'details': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'object_id': type.OptionalType(type.StringType()),
        'rejected': type.OptionalType(type.BooleanType()),
        'resolution': type.OptionalType(type.StringType()),
        'resolved': type.OptionalType(type.BooleanType()),
        'v_object_id': type.OptionalType(type.StringType()),
        'v_object_name': type.OptionalType(type.StringType()),
    },
    SummaryMigrationFeedbackRequest,
    False,
    None))



class SupportBundleFileTransferAuthenticationScheme(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    SCHEME_NAME_PASSWORD = "PASSWORD"
    """


    """



    _canonical_to_pep_names = {
                            'password': 'password',
                            'scheme_name': 'scheme_name',
                            'username': 'username',
                            }

    def __init__(self,
                 password=None,
                 scheme_name=None,
                 username=None,
                ):
        """
        :type  password: :class:`str` or ``None``
        :param password: Password to authenticate with
        :type  scheme_name: :class:`str` or ``None``
        :param scheme_name: Possible values are: 
            
            *
              :attr:`SupportBundleFileTransferAuthenticationScheme.SCHEME_NAME_PASSWORD`
            
             Authentication scheme name
        :type  username: :class:`str` or ``None``
        :param username: User name to authenticate with
        """
        self.password = password
        self.scheme_name = scheme_name
        self.username = username
        VapiStruct.__init__(self)


SupportBundleFileTransferAuthenticationScheme._set_binding_type(type.StructType(
    'com.vmware.nsx.model.support_bundle_file_transfer_authentication_scheme', {
        'password': type.OptionalType(type.StringType()),
        'scheme_name': type.OptionalType(type.StringType()),
        'username': type.OptionalType(type.StringType()),
    },
    SupportBundleFileTransferAuthenticationScheme,
    False,
    None))



class SupportBundleFileTransferProtocol(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    NAME_SCP = "SCP"
    """


    """
    NAME_SFTP = "SFTP"
    """


    """



    _canonical_to_pep_names = {
                            'authentication_scheme': 'authentication_scheme',
                            'name': 'name',
                            'ssh_fingerprint': 'ssh_fingerprint',
                            }

    def __init__(self,
                 authentication_scheme=None,
                 name=None,
                 ssh_fingerprint=None,
                ):
        """
        :type  authentication_scheme: :class:`SupportBundleFileTransferAuthenticationScheme` or ``None``
        :param authentication_scheme: Scheme to authenticate if required
        :type  name: :class:`str` or ``None``
        :param name: Possible values are: 
            
            * :attr:`SupportBundleFileTransferProtocol.NAME_SCP`
            * :attr:`SupportBundleFileTransferProtocol.NAME_SFTP`
            
             Protocol name
        :type  ssh_fingerprint: :class:`str` or ``None``
        :param ssh_fingerprint: SSH fingerprint of server
        """
        self.authentication_scheme = authentication_scheme
        self.name = name
        self.ssh_fingerprint = ssh_fingerprint
        VapiStruct.__init__(self)


SupportBundleFileTransferProtocol._set_binding_type(type.StructType(
    'com.vmware.nsx.model.support_bundle_file_transfer_protocol', {
        'authentication_scheme': type.OptionalType(type.ReferenceType(__name__, 'SupportBundleFileTransferAuthenticationScheme')),
        'name': type.OptionalType(type.StringType()),
        'ssh_fingerprint': type.OptionalType(type.StringType()),
    },
    SupportBundleFileTransferProtocol,
    False,
    None))



class SupportBundleQueryParameters(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'all': 'all',
                            }

    def __init__(self,
                 all=None,
                ):
        """
        :type  all: :class:`bool` or ``None``
        :param all: Include all files including files that may have sensitive
            information like core files.
        """
        self.all = all
        VapiStruct.__init__(self)


SupportBundleQueryParameters._set_binding_type(type.StructType(
    'com.vmware.nsx.model.support_bundle_query_parameters', {
        'all': type.OptionalType(type.BooleanType()),
    },
    SupportBundleQueryParameters,
    False,
    None))



class SupportBundleRemoteFileServer(VapiStruct):
    """
    Remote file server

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'directory_path': 'directory_path',
                            'manager_upload_only': 'manager_upload_only',
                            'port': 'port',
                            'protocol': 'protocol',
                            'server': 'server',
                            }

    def __init__(self,
                 directory_path=None,
                 manager_upload_only=None,
                 port=None,
                 protocol=None,
                 server=None,
                ):
        """
        :type  directory_path: :class:`str` or ``None``
        :param directory_path: Remote server directory to copy bundle files to
        :type  manager_upload_only: :class:`bool` or ``None``
        :param manager_upload_only: Uploads to the remote file server performed by the manager
        :type  port: :class:`long` or ``None``
        :param port: Server port format: int64
        :type  protocol: :class:`SupportBundleFileTransferProtocol` or ``None``
        :param protocol: Protocol to use to copy file
        :type  server: :class:`str` or ``None``
        :param server: Remote server hostname or IP address
        """
        self.directory_path = directory_path
        self.manager_upload_only = manager_upload_only
        self.port = port
        self.protocol = protocol
        self.server = server
        VapiStruct.__init__(self)


SupportBundleRemoteFileServer._set_binding_type(type.StructType(
    'com.vmware.nsx.model.support_bundle_remote_file_server', {
        'directory_path': type.OptionalType(type.StringType()),
        'manager_upload_only': type.OptionalType(type.BooleanType()),
        'port': type.OptionalType(type.IntegerType()),
        'protocol': type.OptionalType(type.ReferenceType(__name__, 'SupportBundleFileTransferProtocol')),
        'server': type.OptionalType(type.StringType()),
    },
    SupportBundleRemoteFileServer,
    False,
    None))



class SupportBundleRequest(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    CONTENT_FILTERS_ALL = "ALL"
    """


    """
    CONTENT_FILTERS_DEFAULT = "DEFAULT"
    """


    """



    _canonical_to_pep_names = {
                            'content_filters': 'content_filters',
                            'log_age_limit': 'log_age_limit',
                            'nodes': 'nodes',
                            'remote_file_server': 'remote_file_server',
                            }

    def __init__(self,
                 content_filters=None,
                 log_age_limit=None,
                 nodes=None,
                 remote_file_server=None,
                ):
        """
        :type  content_filters: :class:`list` of :class:`str` or ``None``
        :param content_filters: Possible values are: 
            
            * :attr:`SupportBundleRequest.CONTENT_FILTERS_ALL`
            * :attr:`SupportBundleRequest.CONTENT_FILTERS_DEFAULT`
            
             Bundle should include content of specified type
        :type  log_age_limit: :class:`long` or ``None``
        :param log_age_limit: Include log files with modified times not past the age limit in
            days format: int64
        :type  nodes: :class:`list` of :class:`str` or ``None``
        :param nodes: List of cluster/fabric node UUIDs processed in specified order
        :type  remote_file_server: :class:`SupportBundleRemoteFileServer` or ``None``
        :param remote_file_server: Remote file server to copy bundles to, bundle in response body if
            not specified
        """
        self.content_filters = content_filters
        self.log_age_limit = log_age_limit
        self.nodes = nodes
        self.remote_file_server = remote_file_server
        VapiStruct.__init__(self)


SupportBundleRequest._set_binding_type(type.StructType(
    'com.vmware.nsx.model.support_bundle_request', {
        'content_filters': type.OptionalType(type.ListType(type.StringType())),
        'log_age_limit': type.OptionalType(type.IntegerType()),
        'nodes': type.OptionalType(type.ListType(type.StringType())),
        'remote_file_server': type.OptionalType(type.ReferenceType(__name__, 'SupportBundleRemoteFileServer')),
    },
    SupportBundleRequest,
    False,
    None))



class SupportBundleResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'failed_nodes': 'failed_nodes',
                            'remaining_nodes': 'remaining_nodes',
                            'request_properties': 'request_properties',
                            'success_nodes': 'success_nodes',
                            }

    def __init__(self,
                 failed_nodes=None,
                 remaining_nodes=None,
                 request_properties=None,
                 success_nodes=None,
                ):
        """
        :type  failed_nodes: :class:`list` of :class:`FailedNodeSupportBundleResult` or ``None``
        :param failed_nodes: Nodes where bundles were not generated or not copied to remote
            server
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  remaining_nodes: :class:`list` of :class:`RemainingSupportBundleNode` or ``None``
        :param remaining_nodes: Nodes where bundle generation is pending or in progress
        :type  request_properties: :class:`SupportBundleRequest` or ``None``
        :param request_properties: Request properties
        :type  success_nodes: :class:`list` of :class:`SuccessNodeSupportBundleResult` or ``None``
        :param success_nodes: Nodes whose bundles were successfully copied to remote file server
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.failed_nodes = failed_nodes
        self.remaining_nodes = remaining_nodes
        self.request_properties = request_properties
        self.success_nodes = success_nodes
        VapiStruct.__init__(self)


SupportBundleResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.support_bundle_result', {
        'failed_nodes': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'FailedNodeSupportBundleResult'))),
        'remaining_nodes': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'RemainingSupportBundleNode'))),
        'request_properties': type.OptionalType(type.ReferenceType(__name__, 'SupportBundleRequest')),
        'success_nodes': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'SuccessNodeSupportBundleResult'))),
    },
    SupportBundleResult,
    False,
    None))



class SupportedHostOSListResult(VapiStruct):
    """
    REST interface for supported host OS types.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`str` or ``None``
        :param results: Supported host OS list results
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


SupportedHostOSListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.supported_host_OS_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.StringType())),
    },
    SupportedHostOSListResult,
    False,
    None))



class SwitchSecuritySwitchingProfile(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "SwitchSecuritySwitchingProfile"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'block_non_ip_traffic': 'block_non_ip_traffic',
                            'bpdu_filter': 'bpdu_filter',
                            'dhcp_filter': 'dhcp_filter',
                            'ra_guard_enabled': 'ra_guard_enabled',
                            'rate_limits': 'rate_limits',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'required_capabilities': 'required_capabilities',
                            }

    def __init__(self,
                 block_non_ip_traffic=None,
                 bpdu_filter=None,
                 dhcp_filter=None,
                 ra_guard_enabled=None,
                 rate_limits=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='SwitchSecuritySwitchingProfile',
                 tags=None,
                 required_capabilities=None,
                ):
        """
        :type  block_non_ip_traffic: :class:`bool` or ``None``
        :param block_non_ip_traffic: A flag to block all traffic except IP/(G)ARP/BPDU
        :type  bpdu_filter: :class:`BpduFilter` or ``None``
        :param bpdu_filter: BPDU filtering is enabled by default. A pre-defined list of MAC
            addresses are automatically excluded from BPDU filtering.
        :type  dhcp_filter: :class:`DhcpFilter` or ``None``
        :param dhcp_filter: DHCP server blocking is enabled and client blocking is disabled by
            default
        :type  ra_guard_enabled: :class:`bool` or ``None``
        :param ra_guard_enabled: RA Guard when enabled blocks unauthorized/rogue Router
            Advertisement (RA) packets.
        :type  rate_limits: :class:`RateLimits` or ``None``
        :param rate_limits: Rate limiting is disabled by default
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: 
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  required_capabilities: :class:`list` of :class:`str` or ``None``
        :param required_capabilities: 
        """
        self.block_non_ip_traffic = block_non_ip_traffic
        self.bpdu_filter = bpdu_filter
        self.dhcp_filter = dhcp_filter
        self.ra_guard_enabled = ra_guard_enabled
        self.rate_limits = rate_limits
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        self.required_capabilities = required_capabilities
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

SwitchSecuritySwitchingProfile._set_binding_type(type.StructType(
    'com.vmware.nsx.model.switch_security_switching_profile', {
        'block_non_ip_traffic': type.OptionalType(type.BooleanType()),
        'bpdu_filter': type.OptionalType(type.ReferenceType(__name__, 'BpduFilter')),
        'dhcp_filter': type.OptionalType(type.ReferenceType(__name__, 'DhcpFilter')),
        'ra_guard_enabled': type.OptionalType(type.BooleanType()),
        'rate_limits': type.OptionalType(type.ReferenceType(__name__, 'RateLimits')),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'required_capabilities': type.OptionalType(type.ListType(type.StringType())),
    },
    SwitchSecuritySwitchingProfile,
    False,
    None))



class SwitchingGlobalConfig(VapiStruct):
    """
    NSX global configs for switching

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "SwitchingGlobalConfig"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'global_replication_mode_enabled': 'global_replication_mode_enabled',
                            'physical_uplink_mtu': 'physical_uplink_mtu',
                            'remote_tunnel_physical_mtu': 'remote_tunnel_physical_mtu',
                            'uplink_mtu_threshold': 'uplink_mtu_threshold',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            }

    def __init__(self,
                 global_replication_mode_enabled=None,
                 physical_uplink_mtu=None,
                 remote_tunnel_physical_mtu=None,
                 uplink_mtu_threshold=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='SwitchingGlobalConfig',
                 tags=None,
                ):
        """
        :type  global_replication_mode_enabled: :class:`bool` or ``None``
        :param global_replication_mode_enabled: When this flag is set true, certain types of BUM packets will be
            sent to all VTEPs in the global VTEP table, ignoring the logical
            switching span.
        :type  physical_uplink_mtu: :class:`long` or ``None``
        :param physical_uplink_mtu: This is the global default MTU for all the physical uplinks in a
            NSX domain. This is the default value for the optional uplink
            profile MTU field. When the MTU value is not specified in the
            uplink profile, this global value will be used. This value can be
            overridden by providing a value for the optional MTU field in the
            uplink profile. Whenever this value is updated, the updated value
            will only be propagated to the uplinks that don't have the MTU
            value in their uplink profiles. If this value is not set, the
            default value of 1700 will be used. The Transport Node state can be
            monitored to confirm if the updated MTU value has been realized.
            format: int32
        :type  remote_tunnel_physical_mtu: :class:`long` or ``None``
        :param remote_tunnel_physical_mtu: This is the global default MTU for all the physical remote tunnel
            endpoints in an NSX domain. Please consider intersite link MTU
            minus any external overhead when defining the MTU. If this value is
            not set, the default value of 1500 will be used. format: int32
        :type  uplink_mtu_threshold: :class:`long` or ``None``
        :param uplink_mtu_threshold: This value defines the upper threshold for the MTU value that can
            be configured at a physical uplink level or a logical routing
            uplink level in a NSX domain. All Uplink profiles validate against
            this value so that the MTU specified in an Uplink profile does not
            exceed this global upper threshold. Similarly, when this value is
            modified, the new value must be greater than or equal to any
            existing Uplink profile's MTU. This value is also validated to be
            greater than or equal to physical_uplink_mtu in
            SwitchingGlobalConfig and logical_uplink_mtu in
            RoutingGlobalConfig. format: int32
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`GlobalConfigs.RESOURCE_TYPE_SWITCHINGGLOBALCONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_ROUTINGGLOBALCONFIG`
            *
              :attr:`GlobalConfigs.RESOURCE_TYPE_OPERATIONCOLLECTORGLOBALCONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_FIREWALLGLOBALCONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_ESXGLOBALOPAQUECONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_SECURITYGLOBALCONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_FIPSGLOBALCONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_FEDERATIONGLOBALCONFIG`
            * :attr:`GlobalConfigs.RESOURCE_TYPE_IDSGLOBALCONFIG`
            
             Valid Global configuration types
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        """
        self.global_replication_mode_enabled = global_replication_mode_enabled
        self.physical_uplink_mtu = physical_uplink_mtu
        self.remote_tunnel_physical_mtu = remote_tunnel_physical_mtu
        self.uplink_mtu_threshold = uplink_mtu_threshold
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

SwitchingGlobalConfig._set_binding_type(type.StructType(
    'com.vmware.nsx.model.switching_global_config', {
        'global_replication_mode_enabled': type.OptionalType(type.BooleanType()),
        'physical_uplink_mtu': type.OptionalType(type.IntegerType()),
        'remote_tunnel_physical_mtu': type.OptionalType(type.IntegerType()),
        'uplink_mtu_threshold': type.OptionalType(type.IntegerType()),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
    },
    SwitchingGlobalConfig,
    False,
    None))



class SwitchingProfileStatus(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'num_logical_ports': 'num_logical_ports',
                            'num_logical_switches': 'num_logical_switches',
                            'switching_profile_id': 'switching_profile_id',
                            }

    def __init__(self,
                 num_logical_ports=None,
                 num_logical_switches=None,
                 switching_profile_id=None,
                ):
        """
        :type  num_logical_ports: :class:`long` or ``None``
        :param num_logical_ports: Number of logical ports using a switching profile format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  num_logical_switches: :class:`long` or ``None``
        :param num_logical_switches: Number of logical switches using a switching profile format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  switching_profile_id: :class:`str` or ``None``
        :param switching_profile_id: Identifier for the switching profile
        """
        self.num_logical_ports = num_logical_ports
        self.num_logical_switches = num_logical_switches
        self.switching_profile_id = switching_profile_id
        VapiStruct.__init__(self)


SwitchingProfileStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.switching_profile_status', {
        'num_logical_ports': type.OptionalType(type.IntegerType()),
        'num_logical_switches': type.OptionalType(type.IntegerType()),
        'switching_profile_id': type.OptionalType(type.StringType()),
    },
    SwitchingProfileStatus,
    False,
    None))



class SwitchingProfileTypeIdEntry(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    KEY_QOSSWITCHINGPROFILE = "QosSwitchingProfile"
    """


    """
    KEY_PORTMIRRORINGSWITCHINGPROFILE = "PortMirroringSwitchingProfile"
    """


    """
    KEY_IPDISCOVERYSWITCHINGPROFILE = "IpDiscoverySwitchingProfile"
    """


    """
    KEY_SPOOFGUARDSWITCHINGPROFILE = "SpoofGuardSwitchingProfile"
    """


    """
    KEY_SWITCHSECURITYSWITCHINGPROFILE = "SwitchSecuritySwitchingProfile"
    """


    """
    KEY_MACMANAGEMENTSWITCHINGPROFILE = "MacManagementSwitchingProfile"
    """


    """



    _canonical_to_pep_names = {
                            'key': 'key',
                            'value': 'value',
                            }

    def __init__(self,
                 key=None,
                 value=None,
                ):
        """
        :type  key: :class:`str` or ``None``
        :param key: Possible values are: 
            
            * :attr:`SwitchingProfileTypeIdEntry.KEY_QOSSWITCHINGPROFILE`
            *
              :attr:`SwitchingProfileTypeIdEntry.KEY_PORTMIRRORINGSWITCHINGPROFILE`
            *
              :attr:`SwitchingProfileTypeIdEntry.KEY_IPDISCOVERYSWITCHINGPROFILE`
            *
              :attr:`SwitchingProfileTypeIdEntry.KEY_SPOOFGUARDSWITCHINGPROFILE`
            *
              :attr:`SwitchingProfileTypeIdEntry.KEY_SWITCHSECURITYSWITCHINGPROFILE`
            *
              :attr:`SwitchingProfileTypeIdEntry.KEY_MACMANAGEMENTSWITCHINGPROFILE`
            
            Supported switching profiles. 'PortMirroringSwitchingProfile' is
            deprecated, please turn to \"Troubleshooting And Monitoring:
            Portmirroring\" and use PortMirroringSession API for port mirror
            function.
        :type  value: :class:`str` or ``None``
        :param value: key value
        """
        self.key = key
        self.value = value
        VapiStruct.__init__(self)


SwitchingProfileTypeIdEntry._set_binding_type(type.StructType(
    'com.vmware.nsx.model.switching_profile_type_id_entry', {
        'key': type.OptionalType(type.StringType()),
        'value': type.OptionalType(type.StringType()),
    },
    SwitchingProfileTypeIdEntry,
    False,
    None))



class SwitchingProfilesListResult(VapiStruct):
    """
    Switching Profile queries result

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param results: Switching Profile Results
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`BaseSwitchingProfile`. When methods return a value of this
            class as a return value, the attribute will contain all the
            attributes defined in :class:`BaseSwitchingProfile`.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


SwitchingProfilesListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.switching_profiles_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'BaseSwitchingProfile')]))),
    },
    SwitchingProfilesListResult,
    False,
    None))



class SwitchingToVmcModeParameters(VapiStruct):
    """
    Possible values of a mode in a \"/config/nsx_appliance_mode\" file

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    MODE_ID_ON_PREM = "ON_PREM"
    """


    """
    MODE_ID_SERVICE = "SERVICE"
    """


    """
    MODE_ID_VMC = "VMC"
    """


    """
    MODE_ID_VMC_LOCAL = "VMC_LOCAL"
    """


    """
    RESOURCE_TYPE_SWITCHINGTOVMCMODEPARAMETERS = "SwitchingToVmcModeParameters"
    """


    """



    _canonical_to_pep_names = {
                            'mode_id': 'mode_id',
                            'auth_code': 'auth_code',
                            'base_url': 'base_url',
                            'basic_auth_whitelist_ips': 'basic_auth_whitelist_ips',
                            'csp_client_credential': 'csp_client_credential',
                            'csp_client_incoming_credentials': 'csp_client_incoming_credentials',
                            'csp_org_uri': 'csp_org_uri',
                            'csp_time_drift': 'csp_time_drift',
                            'default_org_id': 'default_org_id',
                            'ea_org': 'ea_org',
                            'gss_org': 'gss_org',
                            'mode_change_only': 'mode_change_only',
                            'proxy_host': 'proxy_host',
                            'proxy_port': 'proxy_port',
                            'resource_type': 'resource_type',
                            'sddc_id': 'sddc_id',
                            'service_definition_id': 'service_definition_id',
                            'sre_org': 'sre_org',
                            }

    def __init__(self,
                 mode_id=None,
                 auth_code=None,
                 base_url=None,
                 basic_auth_whitelist_ips=None,
                 csp_client_credential=None,
                 csp_client_incoming_credentials=None,
                 csp_org_uri=None,
                 csp_time_drift=None,
                 default_org_id=None,
                 ea_org=None,
                 gss_org=None,
                 mode_change_only=None,
                 proxy_host=None,
                 proxy_port=None,
                 resource_type=None,
                 sddc_id=None,
                 service_definition_id=None,
                 sre_org=None,
                ):
        """
        :type  mode_id: :class:`str` or ``None``
        :param mode_id: Possible values are: 
            
            * :attr:`SwitchingToVmcModeParameters.MODE_ID_ON_PREM`
            * :attr:`SwitchingToVmcModeParameters.MODE_ID_SERVICE`
            * :attr:`SwitchingToVmcModeParameters.MODE_ID_VMC`
            * :attr:`SwitchingToVmcModeParameters.MODE_ID_VMC_LOCAL`
            
             Possible enum values in a \"/config/nsx_appliance_mode\" file
        :type  auth_code: :class:`Oauth2Credentials` or ``None``
        :param auth_code: Client's credentials.
        :type  base_url: :class:`str` or ``None``
        :param base_url: Protocol and domain name (or IP address) of a CSP server, like
            \"https://console-stg.cloud.vmware.com\".
        :type  basic_auth_whitelist_ips: :class:`list` of :class:`str` or ``None``
        :param basic_auth_whitelist_ips: List of whitelist IPs for basic auth
        :type  csp_client_credential: :class:`Oauth2Credentials` or ``None``
        :param csp_client_credential: Client's credentials on CSP server
        :type  csp_client_incoming_credentials: :class:`list` of :class:`str` or ``None``
        :param csp_client_incoming_credentials: List of incoming client IDs
        :type  csp_org_uri: :class:`str` or ``None``
        :param csp_org_uri: Relative path on CSP server to the Org location. Can be
            \"/csp/gateway/am/api/orgs/\".
        :type  csp_time_drift: :class:`long` or ``None``
        :param csp_time_drift: CSP time drift in milliseconds format: int64
        :type  default_org_id: :class:`str` or ``None``
        :param default_org_id: Org ID of a Client - commonly UUID.
        :type  ea_org: :class:`OrgInfo` or ``None``
        :param ea_org: Org ID and role of \"Site Reliability Engineer\"
        :type  gss_org: :class:`OrgInfo` or ``None``
        :param gss_org: Org ID and role of \"Global Support Services\"
        :type  mode_change_only: :class:`bool` or ``None``
        :param mode_change_only: When this parameter is set to true, only a change of the node mode
            happens without any update to the auth properties. When this param
            is not set to true i.e. set to false or not provided, mode change
            and update to the auth properties will both happen.
        :type  proxy_host: :class:`str` or ``None``
        :param proxy_host: IP/host of PoP (Point-of-Presence) HTTP proxy server format:
            hostname-or-ipv4
        :type  proxy_port: :class:`long` or ``None``
        :param proxy_port: Port of PoP (Point-of-Presence) Http proxy server format: int64
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: Possible values are: 
            
            *
              :attr:`SwitchingToVmcModeParameters.RESOURCE_TYPE_SWITCHINGTOVMCMODEPARAMETERS`
            
             Node Mode type
        :type  sddc_id: :class:`str` or ``None``
        :param sddc_id: SDDC id
        :type  service_definition_id: :class:`str` or ``None``
        :param service_definition_id: Service definition id
        :type  sre_org: :class:`OrgInfo` or ``None``
        :param sre_org: Org ID and role of \"Enterprise Admin\"
        """
        self.mode_id = mode_id
        self.auth_code = auth_code
        self.base_url = base_url
        self.basic_auth_whitelist_ips = basic_auth_whitelist_ips
        self.csp_client_credential = csp_client_credential
        self.csp_client_incoming_credentials = csp_client_incoming_credentials
        self.csp_org_uri = csp_org_uri
        self.csp_time_drift = csp_time_drift
        self.default_org_id = default_org_id
        self.ea_org = ea_org
        self.gss_org = gss_org
        self.mode_change_only = mode_change_only
        self.proxy_host = proxy_host
        self.proxy_port = proxy_port
        self.resource_type = resource_type
        self.sddc_id = sddc_id
        self.service_definition_id = service_definition_id
        self.sre_org = sre_org
        VapiStruct.__init__(self)


SwitchingToVmcModeParameters._set_binding_type(type.StructType(
    'com.vmware.nsx.model.switching_to_vmc_mode_parameters', {
        'mode_id': type.OptionalType(type.StringType()),
        'auth_code': type.OptionalType(type.ReferenceType(__name__, 'Oauth2Credentials')),
        'base_url': type.OptionalType(type.StringType()),
        'basic_auth_whitelist_ips': type.OptionalType(type.ListType(type.StringType())),
        'csp_client_credential': type.OptionalType(type.ReferenceType(__name__, 'Oauth2Credentials')),
        'csp_client_incoming_credentials': type.OptionalType(type.ListType(type.StringType())),
        'csp_org_uri': type.OptionalType(type.StringType()),
        'csp_time_drift': type.OptionalType(type.IntegerType()),
        'default_org_id': type.OptionalType(type.StringType()),
        'ea_org': type.OptionalType(type.ReferenceType(__name__, 'OrgInfo')),
        'gss_org': type.OptionalType(type.ReferenceType(__name__, 'OrgInfo')),
        'mode_change_only': type.OptionalType(type.BooleanType()),
        'proxy_host': type.OptionalType(type.StringType()),
        'proxy_port': type.OptionalType(type.IntegerType()),
        'resource_type': type.OptionalType(type.StringType()),
        'sddc_id': type.OptionalType(type.StringType()),
        'service_definition_id': type.OptionalType(type.StringType()),
        'sre_org': type.OptionalType(type.ReferenceType(__name__, 'OrgInfo')),
    },
    SwitchingToVmcModeParameters,
    False,
    None))



class SyslogConfiguration(VapiStruct):
    """
    Syslog server configuration parameters

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    LOG_LEVEL_EMERGENCY = "EMERGENCY"
    """


    """
    LOG_LEVEL_ALERT = "ALERT"
    """


    """
    LOG_LEVEL_CRITICAL = "CRITICAL"
    """


    """
    LOG_LEVEL_ERROR = "ERROR"
    """


    """
    LOG_LEVEL_WARNING = "WARNING"
    """


    """
    LOG_LEVEL_NOTICE = "NOTICE"
    """


    """
    LOG_LEVEL_INFO = "INFO"
    """


    """
    LOG_LEVEL_DEBUG = "DEBUG"
    """


    """
    PROTOCOL_TCP = "TCP"
    """


    """
    PROTOCOL_UDP = "UDP"
    """


    """
    PROTOCOL_TLS = "TLS"
    """


    """
    PROTOCOL_LI = "LI"
    """


    """
    PROTOCOL_LI_TLS = "LI_TLS"
    """


    """



    _canonical_to_pep_names = {
                            'log_level': 'log_level',
                            'name': 'name',
                            'port': 'port',
                            'protocol': 'protocol',
                            'server': 'server',
                            }

    def __init__(self,
                 log_level=None,
                 name=None,
                 port=None,
                 protocol=None,
                 server=None,
                ):
        """
        :type  log_level: :class:`str` or ``None``
        :param log_level: Possible values are: 
            
            * :attr:`SyslogConfiguration.LOG_LEVEL_EMERGENCY`
            * :attr:`SyslogConfiguration.LOG_LEVEL_ALERT`
            * :attr:`SyslogConfiguration.LOG_LEVEL_CRITICAL`
            * :attr:`SyslogConfiguration.LOG_LEVEL_ERROR`
            * :attr:`SyslogConfiguration.LOG_LEVEL_WARNING`
            * :attr:`SyslogConfiguration.LOG_LEVEL_NOTICE`
            * :attr:`SyslogConfiguration.LOG_LEVEL_INFO`
            * :attr:`SyslogConfiguration.LOG_LEVEL_DEBUG`
            
             Log level that needs to be redirected.
        :type  name: :class:`str` or ``None``
        :param name: Display name of the syslog server
        :type  port: :class:`str` or ``None``
        :param port: Syslog server listening port. format: port-or-range
        :type  protocol: :class:`str` or ``None``
        :param protocol: Possible values are: 
            
            * :attr:`SyslogConfiguration.PROTOCOL_TCP`
            * :attr:`SyslogConfiguration.PROTOCOL_UDP`
            * :attr:`SyslogConfiguration.PROTOCOL_TLS`
            * :attr:`SyslogConfiguration.PROTOCOL_LI`
            * :attr:`SyslogConfiguration.PROTOCOL_LI_TLS`
            
             Supported Syslog protocol.
        :type  server: :class:`str` or ``None``
        :param server: Syslog server Ip or fqdn.
        """
        self.log_level = log_level
        self.name = name
        self.port = port
        self.protocol = protocol
        self.server = server
        VapiStruct.__init__(self)


SyslogConfiguration._set_binding_type(type.StructType(
    'com.vmware.nsx.model.syslog_configuration', {
        'log_level': type.OptionalType(type.StringType()),
        'name': type.OptionalType(type.StringType()),
        'port': type.OptionalType(type.StringType()),
        'protocol': type.OptionalType(type.StringType()),
        'server': type.OptionalType(type.StringType()),
    },
    SyslogConfiguration,
    False,
    None))



class SyslogExporter(VapiStruct):
    """
    This object specifies what, where and how logs on NSX nodes are forwarded.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    MAX_LOG_LEVEL_EMERG = "EMERG"
    """


    """
    MAX_LOG_LEVEL_ALERT = "ALERT"
    """


    """
    MAX_LOG_LEVEL_CRIT = "CRIT"
    """


    """
    MAX_LOG_LEVEL_ERR = "ERR"
    """


    """
    MAX_LOG_LEVEL_WARNING = "WARNING"
    """


    """
    MAX_LOG_LEVEL_NOTICE = "NOTICE"
    """


    """
    MAX_LOG_LEVEL_INFO = "INFO"
    """


    """
    MAX_LOG_LEVEL_DEBUG = "DEBUG"
    """


    """
    PROTOCOL_TCP = "TCP"
    """


    """
    PROTOCOL_UDP = "UDP"
    """


    """
    PROTOCOL_LI = "LI"
    """


    """



    _canonical_to_pep_names = {
                            'max_log_level': 'max_log_level',
                            'port': 'port',
                            'protocol': 'protocol',
                            'server': 'server',
                            }

    def __init__(self,
                 max_log_level=None,
                 port=None,
                 protocol=None,
                 server=None,
                ):
        """
        :type  max_log_level: :class:`str` or ``None``
        :param max_log_level: Possible values are: 
            
            * :attr:`SyslogExporter.MAX_LOG_LEVEL_EMERG`
            * :attr:`SyslogExporter.MAX_LOG_LEVEL_ALERT`
            * :attr:`SyslogExporter.MAX_LOG_LEVEL_CRIT`
            * :attr:`SyslogExporter.MAX_LOG_LEVEL_ERR`
            * :attr:`SyslogExporter.MAX_LOG_LEVEL_WARNING`
            * :attr:`SyslogExporter.MAX_LOG_LEVEL_NOTICE`
            * :attr:`SyslogExporter.MAX_LOG_LEVEL_INFO`
            * :attr:`SyslogExporter.MAX_LOG_LEVEL_DEBUG`
            
             Maximum logging level for messages to be exported.
        :type  port: :class:`long` or ``None``
        :param port: Server port on which syslog listener is listening. format: int64
        :type  protocol: :class:`str` or ``None``
        :param protocol: Possible values are: 
            
            * :attr:`SyslogExporter.PROTOCOL_TCP`
            * :attr:`SyslogExporter.PROTOCOL_UDP`
            * :attr:`SyslogExporter.PROTOCOL_LI`
            
             Protocol to be used to export logs to syslog server.
        :type  server: :class:`str` or ``None``
        :param server: Syslog server IP address or hostname. format: hostname-or-ipv4
        """
        self.max_log_level = max_log_level
        self.port = port
        self.protocol = protocol
        self.server = server
        VapiStruct.__init__(self)


SyslogExporter._set_binding_type(type.StructType(
    'com.vmware.nsx.model.syslog_exporter', {
        'max_log_level': type.OptionalType(type.StringType()),
        'port': type.OptionalType(type.IntegerType()),
        'protocol': type.OptionalType(type.StringType()),
        'server': type.OptionalType(type.StringType()),
    },
    SyslogExporter,
    False,
    None))



class SyslogProperties(VapiStruct):
    """
    This object contains list of syslog exporters used by NSX nodes.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'exporters': 'exporters',
                            }

    def __init__(self,
                 exporters=None,
                ):
        """
        :type  exporters: :class:`list` of :class:`SyslogExporter` or ``None``
        :param exporters: List of syslog exporters.
        """
        self.exporters = exporters
        VapiStruct.__init__(self)


SyslogProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.syslog_properties', {
        'exporters': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'SyslogExporter'))),
    },
    SyslogProperties,
    False,
    None))



class SystemHealthAgentProfile(VapiStruct):
    """
    Describes a profile to define a kind of system health agent.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    TYPE_COMPUTE = "COMPUTE"
    """


    """
    TYPE_STORAGE = "STORAGE"
    """


    """
    TYPE_NETWORK = "NETWORK"
    """


    """
    TYPE_HYPERBUS = "HYPERBUS"
    """


    """
    TYPE_NCP = "NCP"
    """


    """
    TYPE_NODEAGENT = "NODEAGENT"
    """


    """
    TYPE_VSAN = "VSAN"
    """


    """
    TYPE_TNAGENT = "TNAGENT"
    """


    """
    TYPE_UPLINK = "UPLINK"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'config': 'config',
                            'enabled': 'enabled',
                            'plugin_id': 'plugin_id',
                            'type': 'type',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 config=None,
                 enabled=None,
                 plugin_id=None,
                 type=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  config: :class:`str` or ``None``
        :param config: The config content of System Health Agent
        :type  enabled: :class:`bool` or ``None``
        :param enabled: The on-off switch of System Health Agent
        :type  plugin_id: :class:`str` or ``None``
        :param plugin_id: The id of System Health Agent plugin
        :type  type: :class:`str` or ``None``
        :param type: Possible values are: 
            
            * :attr:`SystemHealthAgentProfile.TYPE_COMPUTE`
            * :attr:`SystemHealthAgentProfile.TYPE_STORAGE`
            * :attr:`SystemHealthAgentProfile.TYPE_NETWORK`
            * :attr:`SystemHealthAgentProfile.TYPE_HYPERBUS`
            * :attr:`SystemHealthAgentProfile.TYPE_NCP`
            * :attr:`SystemHealthAgentProfile.TYPE_NODEAGENT`
            * :attr:`SystemHealthAgentProfile.TYPE_VSAN`
            * :attr:`SystemHealthAgentProfile.TYPE_TNAGENT`
            * :attr:`SystemHealthAgentProfile.TYPE_UPLINK`
            
             The type of System Health Agent
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.config = config
        self.enabled = enabled
        self.plugin_id = plugin_id
        self.type = type
        VapiStruct.__init__(self)


SystemHealthAgentProfile._set_binding_type(type.StructType(
    'com.vmware.nsx.model.system_health_agent_profile', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'config': type.OptionalType(type.StringType()),
        'enabled': type.OptionalType(type.BooleanType()),
        'plugin_id': type.OptionalType(type.StringType()),
        'type': type.OptionalType(type.StringType()),
    },
    SystemHealthAgentProfile,
    False,
    None))



class SystemHealthAgentProfileListResult(VapiStruct):
    """
    The list result for query of system health profile entity.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`SystemHealthAgentProfile` or ``None``
        :param results: System Health Profile List
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


SystemHealthAgentProfileListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.system_health_agent_profile_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'SystemHealthAgentProfile'))),
    },
    SystemHealthAgentProfileListResult,
    False,
    None))



class SystemHealthPluginProfile(VapiStruct):
    """
    Describes a profile to define a kind of system health plugin.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    TYPE_COMPUTE = "COMPUTE"
    """


    """
    TYPE_STORAGE = "STORAGE"
    """


    """
    TYPE_NETWORK = "NETWORK"
    """


    """
    TYPE_HYPERBUS = "HYPERBUS"
    """


    """
    TYPE_NCP = "NCP"
    """


    """
    TYPE_NODEAGENT = "NODEAGENT"
    """


    """
    TYPE_VSAN = "VSAN"
    """


    """
    TYPE_TNAGENT = "TNAGENT"
    """


    """
    TYPE_UPLINK = "UPLINK"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'publisher': 'publisher',
                            'type': 'type',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 publisher=None,
                 type=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  publisher: :class:`str` or ``None``
        :param publisher: The publisher of System Health Agent plugin
        :type  type: :class:`str` or ``None``
        :param type: Possible values are: 
            
            * :attr:`SystemHealthPluginProfile.TYPE_COMPUTE`
            * :attr:`SystemHealthPluginProfile.TYPE_STORAGE`
            * :attr:`SystemHealthPluginProfile.TYPE_NETWORK`
            * :attr:`SystemHealthPluginProfile.TYPE_HYPERBUS`
            * :attr:`SystemHealthPluginProfile.TYPE_NCP`
            * :attr:`SystemHealthPluginProfile.TYPE_NODEAGENT`
            * :attr:`SystemHealthPluginProfile.TYPE_VSAN`
            * :attr:`SystemHealthPluginProfile.TYPE_TNAGENT`
            * :attr:`SystemHealthPluginProfile.TYPE_UPLINK`
            
             The type of System Health Agent plugin
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.publisher = publisher
        self.type = type
        VapiStruct.__init__(self)


SystemHealthPluginProfile._set_binding_type(type.StructType(
    'com.vmware.nsx.model.system_health_plugin_profile', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'publisher': type.OptionalType(type.StringType()),
        'type': type.OptionalType(type.StringType()),
    },
    SystemHealthPluginProfile,
    False,
    None))



class SystemHealthPluginProfileList(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Total plugin count format: int64
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`SystemHealthPluginProfile` or ``None``
        :param results: System Health plugin list
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


SystemHealthPluginProfileList._set_binding_type(type.StructType(
    'com.vmware.nsx.model.system_health_plugin_profile_list', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'SystemHealthPluginProfile'))),
    },
    SystemHealthPluginProfileList,
    False,
    None))



class Tag(VapiStruct):
    """
    Arbitrary key-value pairs that may be attached to an entity

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'scope': 'scope',
                            'tag': 'tag',
                            }

    def __init__(self,
                 scope=None,
                 tag=None,
                ):
        """
        :type  scope: :class:`str` or ``None``
        :param scope: Tag searches may optionally be restricted by scope
        :type  tag: :class:`str` or ``None``
        :param tag: Identifier meaningful to user with maximum length of 256 characters
        """
        self.scope = scope
        self.tag = tag
        VapiStruct.__init__(self)


Tag._set_binding_type(type.StructType(
    'com.vmware.nsx.model.tag', {
        'scope': type.OptionalType(type.StringType()),
        'tag': type.OptionalType(type.StringType()),
    },
    Tag,
    False,
    None))



class TargetResourceStatus(VapiStruct):
    """
    Holds status of target resource in firewall context.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    TARGET_STATUS_DISABLED = "DISABLED"
    """


    """
    TARGET_STATUS_ENABLED = "ENABLED"
    """


    """



    _canonical_to_pep_names = {
                            'target_id': 'target_id',
                            'target_status': 'target_status',
                            }

    def __init__(self,
                 target_id=None,
                 target_status=None,
                ):
        """
        :type  target_id: :class:`str` or ``None``
        :param target_id: Identifier of the NSX resource.
        :type  target_status: :class:`str` or ``None``
        :param target_status: Possible values are: 
            
            * :attr:`TargetResourceStatus.TARGET_STATUS_DISABLED`
            * :attr:`TargetResourceStatus.TARGET_STATUS_ENABLED`
            
             Firewall status on a target logical resource.
        """
        self.target_id = target_id
        self.target_status = target_status
        VapiStruct.__init__(self)


TargetResourceStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.target_resource_status', {
        'target_id': type.OptionalType(type.StringType()),
        'target_status': type.OptionalType(type.StringType()),
    },
    TargetResourceStatus,
    False,
    None))



class TaskListResult(VapiStruct):
    """
    Task query results

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`TaskProperties` or ``None``
        :param results: Task property results
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


TaskListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.task_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'TaskProperties'))),
    },
    TaskListResult,
    False,
    None))



class TaskProperties(VapiStruct):
    """
    Task properties

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATUS_RUNNING = "running"
    """


    """
    STATUS_ERROR = "error"
    """


    """
    STATUS_SUCCESS = "success"
    """


    """
    STATUS_CANCELING = "canceling"
    """


    """
    STATUS_CANCELED = "canceled"
    """


    """
    STATUS_KILLED = "killed"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'async_response_available': 'async_response_available',
                            'cancelable': 'cancelable',
                            'description': 'description',
                            'end_time': 'end_time',
                            'id': 'id',
                            'message': 'message',
                            'progress': 'progress',
                            'request_method': 'request_method',
                            'request_uri': 'request_uri',
                            'start_time': 'start_time',
                            'status': 'status',
                            'user': 'user',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 async_response_available=None,
                 cancelable=None,
                 description=None,
                 end_time=None,
                 id=None,
                 message=None,
                 progress=None,
                 request_method=None,
                 request_uri=None,
                 start_time=None,
                 status=None,
                 user=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  async_response_available: :class:`bool` or ``None``
        :param async_response_available: True if response for asynchronous request is available
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  cancelable: :class:`bool` or ``None``
        :param cancelable: True if this task can be canceled
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of the task
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  end_time: :class:`long` or ``None``
        :param end_time: The end time of the task in epoch milliseconds format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  id: :class:`str` or ``None``
        :param id: Identifier for this task
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  message: :class:`str` or ``None``
        :param message: A message describing the disposition of the task
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  progress: :class:`long` or ``None``
        :param progress: Task progress if known, from 0 to 100 format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  request_method: :class:`str` or ``None``
        :param request_method: HTTP request method
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  request_uri: :class:`str` or ``None``
        :param request_uri: URI of the method invocation that spawned this task
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  start_time: :class:`long` or ``None``
        :param start_time: The start time of the task in epoch milliseconds format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  status: :class:`str` or ``None``
        :param status: Possible values are: 
            
            * :attr:`TaskProperties.STATUS_RUNNING`
            * :attr:`TaskProperties.STATUS_ERROR`
            * :attr:`TaskProperties.STATUS_SUCCESS`
            * :attr:`TaskProperties.STATUS_CANCELING`
            * :attr:`TaskProperties.STATUS_CANCELED`
            * :attr:`TaskProperties.STATUS_KILLED`
            
             Current status of the task
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  user: :class:`str` or ``None``
        :param user: Name of the user who created this task
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.async_response_available = async_response_available
        self.cancelable = cancelable
        self.description = description
        self.end_time = end_time
        self.id = id
        self.message = message
        self.progress = progress
        self.request_method = request_method
        self.request_uri = request_uri
        self.start_time = start_time
        self.status = status
        self.user = user
        VapiStruct.__init__(self)


TaskProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.task_properties', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'async_response_available': type.OptionalType(type.BooleanType()),
        'cancelable': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'end_time': type.OptionalType(type.IntegerType()),
        'id': type.OptionalType(type.StringType()),
        'message': type.OptionalType(type.StringType()),
        'progress': type.OptionalType(type.IntegerType()),
        'request_method': type.OptionalType(type.StringType()),
        'request_uri': type.OptionalType(type.StringType()),
        'start_time': type.OptionalType(type.IntegerType()),
        'status': type.OptionalType(type.StringType()),
        'user': type.OptionalType(type.StringType()),
    },
    TaskProperties,
    False,
    None))



class TcpHeader(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'dst_port': 'dst_port',
                            'src_port': 'src_port',
                            'tcp_flags': 'tcp_flags',
                            }

    def __init__(self,
                 dst_port=None,
                 src_port=None,
                 tcp_flags=None,
                ):
        """
        :type  dst_port: :class:`long` or ``None``
        :param dst_port: Destination port of tcp header format: int64
        :type  src_port: :class:`long` or ``None``
        :param src_port: Source port of tcp header format: int64
        :type  tcp_flags: :class:`long` or ``None``
        :param tcp_flags: TCP flags (9bits) format: int64
        """
        self.dst_port = dst_port
        self.src_port = src_port
        self.tcp_flags = tcp_flags
        VapiStruct.__init__(self)


TcpHeader._set_binding_type(type.StructType(
    'com.vmware.nsx.model.tcp_header', {
        'dst_port': type.OptionalType(type.IntegerType()),
        'src_port': type.OptionalType(type.IntegerType()),
        'tcp_flags': type.OptionalType(type.IntegerType()),
    },
    TcpHeader,
    False,
    None))



class TcpMssClamping(VapiStruct):
    """
    Tcp Mss Clamping Direction and value

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    DIRECTION_NONE = "NONE"
    """


    """
    DIRECTION_INBOUND_CONNECTION = "INBOUND_CONNECTION"
    """


    """
    DIRECTION_OUTBOUND_CONNECTION = "OUTBOUND_CONNECTION"
    """


    """
    DIRECTION_BOTH = "BOTH"
    """


    """



    _canonical_to_pep_names = {
                            'direction': 'direction',
                            'max_segment_size': 'max_segment_size',
                            }

    def __init__(self,
                 direction=None,
                 max_segment_size=None,
                ):
        """
        :type  direction: :class:`str` or ``None``
        :param direction: Possible values are: 
            
            * :attr:`TcpMssClamping.DIRECTION_NONE`
            * :attr:`TcpMssClamping.DIRECTION_INBOUND_CONNECTION`
            * :attr:`TcpMssClamping.DIRECTION_OUTBOUND_CONNECTION`
            * :attr:`TcpMssClamping.DIRECTION_BOTH`
            
             Specifies the traffic direction for which to apply MSS Clamping.
        :type  max_segment_size: :class:`long` or ``None``
        :param max_segment_size: It defines the maximum amount of data that a host is willing to
            accept in a single TCP segment. This field is set in TCP header
            during connection establishment. To avoid packet fragmentation, you
            can set this field depending on uplink MTU and VPN overhead. This
            is optional field and in case it is left unconfigured, best
            possible MSS value will be calculated based on effective mtu of
            uplink interface. Supported MSS range is 108 to 8852. format: int64
        """
        self.direction = direction
        self.max_segment_size = max_segment_size
        VapiStruct.__init__(self)


TcpMssClamping._set_binding_type(type.StructType(
    'com.vmware.nsx.model.tcp_mss_clamping', {
        'direction': type.OptionalType(type.StringType()),
        'max_segment_size': type.OptionalType(type.IntegerType()),
    },
    TcpMssClamping,
    False,
    None))



class TeamingPolicy(VapiStruct):
    """
    Uplink Teaming Policy

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    POLICY_FAILOVER_ORDER = "FAILOVER_ORDER"
    """


    """
    POLICY_LOADBALANCE_SRCID = "LOADBALANCE_SRCID"
    """


    """
    POLICY_LOADBALANCE_SRC_MAC = "LOADBALANCE_SRC_MAC"
    """


    """



    _canonical_to_pep_names = {
                            'active_list': 'active_list',
                            'policy': 'policy',
                            'standby_list': 'standby_list',
                            }

    def __init__(self,
                 active_list=None,
                 policy=None,
                 standby_list=None,
                ):
        """
        :type  active_list: :class:`list` of :class:`Uplink` or ``None``
        :param active_list: List of Uplinks used in active list
        :type  policy: :class:`str` or ``None``
        :param policy: Possible values are: 
            
            * :attr:`TeamingPolicy.POLICY_FAILOVER_ORDER`
            * :attr:`TeamingPolicy.POLICY_LOADBALANCE_SRCID`
            * :attr:`TeamingPolicy.POLICY_LOADBALANCE_SRC_MAC`
            
             Teaming policy
        :type  standby_list: :class:`list` of :class:`Uplink` or ``None``
        :param standby_list: List of Uplinks used in standby list
        """
        self.active_list = active_list
        self.policy = policy
        self.standby_list = standby_list
        VapiStruct.__init__(self)


TeamingPolicy._set_binding_type(type.StructType(
    'com.vmware.nsx.model.teaming_policy', {
        'active_list': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Uplink'))),
        'policy': type.OptionalType(type.StringType()),
        'standby_list': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Uplink'))),
    },
    TeamingPolicy,
    False,
    None))



class TelemetryAgreement(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'telemetry_agreement_displayed': 'telemetry_agreement_displayed',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 telemetry_agreement_displayed=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  telemetry_agreement_displayed: :class:`bool` or ``None``
        :param telemetry_agreement_displayed: Determine if telemetry agreement has been displayed. If false, the
            agreement text will be displayed at login time.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.telemetry_agreement_displayed = telemetry_agreement_displayed
        VapiStruct.__init__(self)


TelemetryAgreement._set_binding_type(type.StructType(
    'com.vmware.nsx.model.telemetry_agreement', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'telemetry_agreement_displayed': type.OptionalType(type.BooleanType()),
    },
    TelemetryAgreement,
    False,
    None))



class TelemetryConfig(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'ceip_acceptance': 'ceip_acceptance',
                            'proxy_enabled': 'proxy_enabled',
                            'schedule_enabled': 'schedule_enabled',
                            'telemetry_proxy': 'telemetry_proxy',
                            'telemetry_schedule': 'telemetry_schedule',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 ceip_acceptance=None,
                 proxy_enabled=None,
                 schedule_enabled=None,
                 telemetry_proxy=None,
                 telemetry_schedule=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  ceip_acceptance: :class:`bool` or ``None``
        :param ceip_acceptance: Enable this flag to participate in the Customer Experience
            Improvement Program.
        :type  proxy_enabled: :class:`bool` or ``None``
        :param proxy_enabled: Enable this flag to specify a proxy, and provide the proxy
            settings.
        :type  schedule_enabled: :class:`bool` or ``None``
        :param schedule_enabled: Enable this to schedule data collection and upload times. If
            enabled, and a schedule is not provided, a default schedule
            (WEEKLY, Sunday at 2:00 a.m) will be applied.
        :type  telemetry_proxy: :class:`TelemetryProxy` or ``None``
        :param telemetry_proxy: Specify the proxy configuration (scheme, server, port) here.
        :type  telemetry_schedule: :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param telemetry_schedule: Specify one of Daily, Weekly or Monthly schedules.
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`TelemetrySchedule`. When methods return a value of this
            class as a return value, the attribute will contain all the
            attributes defined in :class:`TelemetrySchedule`.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.ceip_acceptance = ceip_acceptance
        self.proxy_enabled = proxy_enabled
        self.schedule_enabled = schedule_enabled
        self.telemetry_proxy = telemetry_proxy
        self.telemetry_schedule = telemetry_schedule
        VapiStruct.__init__(self)


TelemetryConfig._set_binding_type(type.StructType(
    'com.vmware.nsx.model.telemetry_config', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'ceip_acceptance': type.OptionalType(type.BooleanType()),
        'proxy_enabled': type.OptionalType(type.BooleanType()),
        'schedule_enabled': type.OptionalType(type.BooleanType()),
        'telemetry_proxy': type.OptionalType(type.ReferenceType(__name__, 'TelemetryProxy')),
        'telemetry_schedule': type.OptionalType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'TelemetrySchedule')])),
    },
    TelemetryConfig,
    False,
    None))



class TelemetryProxy(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    SCHEME_HTTP = "HTTP"
    """


    """
    SCHEME_HTTPS = "HTTPS"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'hostname': 'hostname',
                            'password': 'password',
                            'port': 'port',
                            'scheme': 'scheme',
                            'username': 'username',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 hostname=None,
                 password=None,
                 port=None,
                 scheme=None,
                 username=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  hostname: :class:`str` or ``None``
        :param hostname: Specify the fully qualified domain name, or ip address, of the
            proxy server. format: hostname-or-ip
        :type  password: :class:`str` or ``None``
        :param password: Specify the password used to authenticate with the proxy server, if
            required. A GET call on /telemetry/config returns a non-meaningful
            password to maintain security. To change the password to a new
            value, issue a PUT call after updating this field. To remove the
            password, issue a PUT call after emptying this field. To retain a
            previously set password, issue a PUT call keeping the
            non-meaningful value obtained from the GET call.
        :type  port: :class:`long` or ``None``
        :param port: Specify the port of the proxy server. format: int32
        :type  scheme: :class:`str` or ``None``
        :param scheme: Possible values are: 
            
            * :attr:`TelemetryProxy.SCHEME_HTTP`
            * :attr:`TelemetryProxy.SCHEME_HTTPS`
            
            The scheme accepted by the proxy server. Specify one of HTTP and
            HTTPS.
        :type  username: :class:`str` or ``None``
        :param username: Specify the user name used to authenticate with the proxy server,
            if required.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.hostname = hostname
        self.password = password
        self.port = port
        self.scheme = scheme
        self.username = username
        VapiStruct.__init__(self)


TelemetryProxy._set_binding_type(type.StructType(
    'com.vmware.nsx.model.telemetry_proxy', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'hostname': type.OptionalType(type.StringType()),
        'password': type.OptionalType(type.StringType()),
        'port': type.OptionalType(type.IntegerType()),
        'scheme': type.OptionalType(type.StringType()),
        'username': type.OptionalType(type.StringType()),
    },
    TelemetryProxy,
    False,
    None))



class TelemetrySchedule(VapiStruct):
    """
    Abstract base type for telemetry schedule configuration

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "TelemetrySchedule"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'frequency_type': 'frequency_type',
                            }

    def __init__(self,
                 frequency_type='TelemetrySchedule',
                ):
        """
        :type  frequency_type: :class:`str`
        :param frequency_type: Specify one of DailyTelemetrySchedule, WeeklyTelemetrySchedule, or
            MonthlyTelemetrySchedule.
        """
        self._frequency_type = frequency_type
        VapiStruct.__init__(self)

    @property
    def frequency_type(self):
        """
        Return the discriminator value
        """
        return self._frequency_type

TelemetrySchedule._set_binding_type(type.StructType(
    'com.vmware.nsx.model.telemetry_schedule', {
        'frequency_type': type.StringType(),
    },
    TelemetrySchedule,
    False,
    None))



class ThreatStatus(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATUS_NORMAL = "NORMAL"
    """


    """
    STATUS_ABNORMAL = "ABNORMAL"
    """


    """



    _canonical_to_pep_names = {
                            'status': 'status',
                            }

    def __init__(self,
                 status=None,
                ):
        """
        :type  status: :class:`str` or ``None``
        :param status: Possible values are: 
            
            * :attr:`ThreatStatus.STATUS_NORMAL`
            * :attr:`ThreatStatus.STATUS_ABNORMAL`
            
             Transport node threat status
        """
        self.status = status
        VapiStruct.__init__(self)


ThreatStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.threat_status', {
        'status': type.OptionalType(type.StringType()),
    },
    ThreatStatus,
    False,
    None))



class TnHyperbusStatus(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    HYPERBUS_STATUS_UNKNOWN = "UNKNOWN"
    """


    """
    HYPERBUS_STATUS_HEALTHY = "HEALTHY"
    """


    """
    HYPERBUS_STATUS_UNHEALTHY = "UNHEALTHY"
    """


    """
    HYPERBUS_STATUS_DEGRADED = "DEGRADED"
    """


    """



    _canonical_to_pep_names = {
                            'hyperbus_status': 'hyperbus_status',
                            'transport_node_id': 'transport_node_id',
                            }

    def __init__(self,
                 hyperbus_status=None,
                 transport_node_id=None,
                ):
        """
        :type  hyperbus_status: :class:`str` or ``None``
        :param hyperbus_status: Possible values are: 
            
            * :attr:`TnHyperbusStatus.HYPERBUS_STATUS_UNKNOWN`
            * :attr:`TnHyperbusStatus.HYPERBUS_STATUS_HEALTHY`
            * :attr:`TnHyperbusStatus.HYPERBUS_STATUS_UNHEALTHY`
            * :attr:`TnHyperbusStatus.HYPERBUS_STATUS_DEGRADED`
            
             Display the hyperbus status
        :type  transport_node_id: :class:`str` or ``None``
        :param transport_node_id: Transport node id.
        """
        self.hyperbus_status = hyperbus_status
        self.transport_node_id = transport_node_id
        VapiStruct.__init__(self)


TnHyperbusStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.tn_hyperbus_status', {
        'hyperbus_status': type.OptionalType(type.StringType()),
        'transport_node_id': type.OptionalType(type.StringType()),
    },
    TnHyperbusStatus,
    False,
    None))



class TnNodeAgentStatusListResult(VapiStruct):
    """
    Container agent status list result

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`TnNodeAgentstatus` or ``None``
        :param results: Container agent status
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


TnNodeAgentStatusListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.tn_node_agent_status_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'TnNodeAgentstatus'))),
    },
    TnNodeAgentStatusListResult,
    False,
    None))



class TnNodeAgentstatus(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    HYPERBUS_CONNECTION_STATUS_UNKNOWN = "UNKNOWN"
    """


    """
    HYPERBUS_CONNECTION_STATUS_HEALTHY = "HEALTHY"
    """


    """
    HYPERBUS_CONNECTION_STATUS_UNHEALTHY = "UNHEALTHY"
    """


    """
    HYPERBUS_CONNECTION_STATUS_DEGRADED = "DEGRADED"
    """


    """



    _canonical_to_pep_names = {
                            'hyperbus_connection_status': 'hyperbus_connection_status',
                            'vif_id': 'vif_id',
                            }

    def __init__(self,
                 hyperbus_connection_status=None,
                 vif_id=None,
                ):
        """
        :type  hyperbus_connection_status: :class:`str` or ``None``
        :param hyperbus_connection_status: Possible values are: 
            
            * :attr:`TnNodeAgentstatus.HYPERBUS_CONNECTION_STATUS_UNKNOWN`
            * :attr:`TnNodeAgentstatus.HYPERBUS_CONNECTION_STATUS_HEALTHY`
            * :attr:`TnNodeAgentstatus.HYPERBUS_CONNECTION_STATUS_UNHEALTHY`
            * :attr:`TnNodeAgentstatus.HYPERBUS_CONNECTION_STATUS_DEGRADED`
            
             Show the Node Agent connected VM vif status.
        :type  vif_id: :class:`str` or ``None``
        :param vif_id: Connected VM vif id.
        """
        self.hyperbus_connection_status = hyperbus_connection_status
        self.vif_id = vif_id
        VapiStruct.__init__(self)


TnNodeAgentstatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.tn_node_agentstatus', {
        'hyperbus_connection_status': type.OptionalType(type.StringType()),
        'vif_id': type.OptionalType(type.StringType()),
    },
    TnNodeAgentstatus,
    False,
    None))



class TokenBasedPrincipalIdentity(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'is_protected': 'is_protected',
                            'name': 'name',
                            'node_id': 'node_id',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 is_protected=None,
                 name=None,
                 node_id=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  is_protected: :class:`bool` or ``None``
        :param is_protected: Indicator whether the entities created by this principal should be
            protected.
        :type  name: :class:`str` or ``None``
        :param name: Name of the principal. This will be matched to the name provided in
            the token.
        :type  node_id: :class:`str` or ``None``
        :param node_id: Unique node-id of a principal.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.is_protected = is_protected
        self.name = name
        self.node_id = node_id
        VapiStruct.__init__(self)


TokenBasedPrincipalIdentity._set_binding_type(type.StructType(
    'com.vmware.nsx.model.token_based_principal_identity', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'is_protected': type.OptionalType(type.BooleanType()),
        'name': type.OptionalType(type.StringType()),
        'node_id': type.OptionalType(type.StringType()),
    },
    TokenBasedPrincipalIdentity,
    False,
    None))



class TokenBasedPrincipalIdentityListResult(VapiStruct):
    """
    Token-based PrincipalIdentity query result

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`TokenBasedPrincipalIdentity` or ``None``
        :param results: TokenBasedPrincipalIdentity list.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


TokenBasedPrincipalIdentityListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.token_based_principal_identity_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'TokenBasedPrincipalIdentity'))),
    },
    TokenBasedPrincipalIdentityListResult,
    False,
    None))



class Tooltip(VapiStruct):
    """
    Tooltip to be shown while hovering over the dashboard UI element.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'condition': 'condition',
                            'heading': 'heading',
                            'text': 'text',
                            }

    def __init__(self,
                 condition=None,
                 heading=None,
                 text=None,
                ):
        """
        :type  condition: :class:`str` or ``None``
        :param condition: If the condition is met then the tooltip will be applied. If no
            condition is provided, then the tooltip will be applied
            unconditionally. Examples of expression syntax are provided under
            'example_request' section of 'CreateWidgetConfiguration' API.
        :type  heading: :class:`bool` or ``None``
        :param heading: If true, displays tooltip text in bold
        :type  text: :class:`str` or ``None``
        :param text: Text to be shown on tooltip while hovering over UI element. The
            text would be wrapped if it exceeds 80 chars.
        """
        self.condition = condition
        self.heading = heading
        self.text = text
        VapiStruct.__init__(self)


Tooltip._set_binding_type(type.StructType(
    'com.vmware.nsx.model.tooltip', {
        'condition': type.OptionalType(type.StringType()),
        'heading': type.OptionalType(type.BooleanType()),
        'text': type.OptionalType(type.StringType()),
    },
    Tooltip,
    False,
    None))



class Traceflow(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    OPERATION_STATE_IN_PROGRESS = "IN_PROGRESS"
    """


    """
    OPERATION_STATE_FINISHED = "FINISHED"
    """


    """
    OPERATION_STATE_FAILED = "FAILED"
    """


    """
    REQUEST_STATUS_SUCCESS = "SUCCESS"
    """


    """
    REQUEST_STATUS_TIMEOUT = "TIMEOUT"
    """


    """
    REQUEST_STATUS_SOURCE_PORT_NOT_FOUND = "SOURCE_PORT_NOT_FOUND"
    """


    """
    REQUEST_STATUS_DATA_PATH_NOT_READY = "DATA_PATH_NOT_READY"
    """


    """
    REQUEST_STATUS_CONNECTION_ERROR = "CONNECTION_ERROR"
    """


    """
    REQUEST_STATUS_UNKNOWN = "UNKNOWN"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'analysis': 'analysis',
                            'counters': 'counters',
                            'logical_counters': 'logical_counters',
                            'lport_id': 'lport_id',
                            'operation_state': 'operation_state',
                            'request_status': 'request_status',
                            'result_overflowed': 'result_overflowed',
                            'timeout': 'timeout',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 analysis=None,
                 counters=None,
                 logical_counters=None,
                 lport_id=None,
                 operation_state=None,
                 request_status=None,
                 result_overflowed=None,
                 timeout=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: The id of the traceflow round
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  analysis: :class:`list` of :class:`str` or ``None``
        :param analysis: Traceflow result analysis notes
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  counters: :class:`TraceflowObservationCounters` or ``None``
        :param counters: observation counters
        :type  logical_counters: :class:`TraceflowObservationCounters` or ``None``
        :param logical_counters: counters of observations from logical components
        :type  lport_id: :class:`str` or ``None``
        :param lport_id: id of the source logical port used for injecting the traceflow
            packet
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  operation_state: :class:`str` or ``None``
        :param operation_state: Possible values are: 
            
            * :attr:`Traceflow.OPERATION_STATE_IN_PROGRESS`
            * :attr:`Traceflow.OPERATION_STATE_FINISHED`
            * :attr:`Traceflow.OPERATION_STATE_FAILED`
            
             Represents the traceflow operation state
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  request_status: :class:`str` or ``None``
        :param request_status: Possible values are: 
            
            * :attr:`Traceflow.REQUEST_STATUS_SUCCESS`
            * :attr:`Traceflow.REQUEST_STATUS_TIMEOUT`
            * :attr:`Traceflow.REQUEST_STATUS_SOURCE_PORT_NOT_FOUND`
            * :attr:`Traceflow.REQUEST_STATUS_DATA_PATH_NOT_READY`
            * :attr:`Traceflow.REQUEST_STATUS_CONNECTION_ERROR`
            * :attr:`Traceflow.REQUEST_STATUS_UNKNOWN`
            
            The status of the traceflow RPC request. SUCCESS - The traceflow
            request is sent successfully. TIMEOUT - The traceflow request gets
            timeout. SOURCE_PORT_NOT_FOUND - The source port of the request
            cannot be found. DATA_PATH_NOT_READY - The datapath component
            cannot be ready to receive request. CONNECTION_ERROR - There is
            connection error on datapath component. UNKNOWN - The status of
            traceflow request cannot be determined.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_overflowed: :class:`bool` or ``None``
        :param result_overflowed: A flag, when set true, indicates some observations were deleted
            from the result set.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  timeout: :class:`long` or ``None``
        :param timeout: Maximum time (in ms) the management plane will be waiting for this
            traceflow round. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.analysis = analysis
        self.counters = counters
        self.logical_counters = logical_counters
        self.lport_id = lport_id
        self.operation_state = operation_state
        self.request_status = request_status
        self.result_overflowed = result_overflowed
        self.timeout = timeout
        VapiStruct.__init__(self)


Traceflow._set_binding_type(type.StructType(
    'com.vmware.nsx.model.traceflow', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'analysis': type.OptionalType(type.ListType(type.StringType())),
        'counters': type.OptionalType(type.ReferenceType(__name__, 'TraceflowObservationCounters')),
        'logical_counters': type.OptionalType(type.ReferenceType(__name__, 'TraceflowObservationCounters')),
        'lport_id': type.OptionalType(type.StringType()),
        'operation_state': type.OptionalType(type.StringType()),
        'request_status': type.OptionalType(type.StringType()),
        'result_overflowed': type.OptionalType(type.BooleanType()),
        'timeout': type.OptionalType(type.IntegerType()),
    },
    Traceflow,
    False,
    None))



class TraceflowListResult(VapiStruct):
    """
    Traceflow queries result

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`Traceflow` or ``None``
        :param results: Traceflow Results
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


TraceflowListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.traceflow_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Traceflow'))),
    },
    TraceflowListResult,
    False,
    None))



class TraceflowObservation(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "TraceflowObservation"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    COMPONENT_SUB_TYPE_LR_TIER0 = "LR_TIER0"
    """


    """
    COMPONENT_SUB_TYPE_LR_TIER1 = "LR_TIER1"
    """


    """
    COMPONENT_SUB_TYPE_LR_VRF_TIER0 = "LR_VRF_TIER0"
    """


    """
    COMPONENT_SUB_TYPE_LS_TRANSIT = "LS_TRANSIT"
    """


    """
    COMPONENT_SUB_TYPE_SI_CLASSIFIER = "SI_CLASSIFIER"
    """


    """
    COMPONENT_SUB_TYPE_SI_PROXY = "SI_PROXY"
    """


    """
    COMPONENT_SUB_TYPE_VDR = "VDR"
    """


    """
    COMPONENT_SUB_TYPE_ENI = "ENI"
    """


    """
    COMPONENT_SUB_TYPE_AWS_GATEWAY = "AWS_GATEWAY"
    """


    """
    COMPONENT_SUB_TYPE_TGW_ROUTE = "TGW_ROUTE"
    """


    """
    COMPONENT_SUB_TYPE_EDGE_UPLINK = "EDGE_UPLINK"
    """


    """
    COMPONENT_SUB_TYPE_DELL_GATEWAY = "DELL_GATEWAY"
    """


    """
    COMPONENT_SUB_TYPE_UNKNOWN = "UNKNOWN"
    """


    """
    COMPONENT_TYPE_PHYSICAL = "PHYSICAL"
    """


    """
    COMPONENT_TYPE_LR = "LR"
    """


    """
    COMPONENT_TYPE_LS = "LS"
    """


    """
    COMPONENT_TYPE_DFW = "DFW"
    """


    """
    COMPONENT_TYPE_BRIDGE = "BRIDGE"
    """


    """
    COMPONENT_TYPE_EDGE_TUNNEL = "EDGE_TUNNEL"
    """


    """
    COMPONENT_TYPE_EDGE_HOSTSWITCH = "EDGE_HOSTSWITCH"
    """


    """
    COMPONENT_TYPE_FW_BRIDGE = "FW_BRIDGE"
    """


    """
    COMPONENT_TYPE_LOAD_BALANCER = "LOAD_BALANCER"
    """


    """
    COMPONENT_TYPE_NAT = "NAT"
    """


    """
    COMPONENT_TYPE_IPSEC = "IPSEC"
    """


    """
    COMPONENT_TYPE_SERVICE_INSERTION = "SERVICE_INSERTION"
    """


    """
    COMPONENT_TYPE_VMC = "VMC"
    """


    """
    COMPONENT_TYPE_SPOOFGUARD = "SPOOFGUARD"
    """


    """
    COMPONENT_TYPE_EDGE_FW = "EDGE_FW"
    """


    """
    COMPONENT_TYPE_UNKNOWN = "UNKNOWN"
    """


    """
    RESOURCE_TYPE_TRACEFLOWOBSERVATIONFORWARDED = "TraceflowObservationForwarded"
    """


    """
    RESOURCE_TYPE_TRACEFLOWOBSERVATIONDROPPED = "TraceflowObservationDropped"
    """


    """
    RESOURCE_TYPE_TRACEFLOWOBSERVATIONDELIVERED = "TraceflowObservationDelivered"
    """


    """
    RESOURCE_TYPE_TRACEFLOWOBSERVATIONRECEIVED = "TraceflowObservationReceived"
    """


    """
    RESOURCE_TYPE_TRACEFLOWOBSERVATIONFORWARDEDLOGICAL = "TraceflowObservationForwardedLogical"
    """


    """
    RESOURCE_TYPE_TRACEFLOWOBSERVATIONDROPPEDLOGICAL = "TraceflowObservationDroppedLogical"
    """


    """
    RESOURCE_TYPE_TRACEFLOWOBSERVATIONRECEIVEDLOGICAL = "TraceflowObservationReceivedLogical"
    """


    """
    RESOURCE_TYPE_TRACEFLOWOBSERVATIONREPLICATIONLOGICAL = "TraceflowObservationReplicationLogical"
    """


    """
    RESOURCE_TYPE_TRACEFLOWOBSERVATIONRELAYEDLOGICAL = "TraceflowObservationRelayedLogical"
    """


    """
    TRANSPORT_NODE_TYPE_ESX = "ESX"
    """


    """
    TRANSPORT_NODE_TYPE_RHELKVM = "RHELKVM"
    """


    """
    TRANSPORT_NODE_TYPE_UBUNTUKVM = "UBUNTUKVM"
    """


    """
    TRANSPORT_NODE_TYPE_EDGE = "EDGE"
    """


    """
    TRANSPORT_NODE_TYPE_PUBLIC_CLOUD_GATEWAY_NODE = "PUBLIC_CLOUD_GATEWAY_NODE"
    """


    """
    TRANSPORT_NODE_TYPE_OTHERS = "OTHERS"
    """


    """
    TRANSPORT_NODE_TYPE_HYPERV = "HYPERV"
    """


    """



    _canonical_to_pep_names = {
                            'component_name': 'component_name',
                            'component_sub_type': 'component_sub_type',
                            'component_type': 'component_type',
                            'resource_type': 'resource_type',
                            'sequence_no': 'sequence_no',
                            'timestamp': 'timestamp',
                            'timestamp_micro': 'timestamp_micro',
                            'transport_node_id': 'transport_node_id',
                            'transport_node_name': 'transport_node_name',
                            'transport_node_type': 'transport_node_type',
                            }

    def __init__(self,
                 component_name=None,
                 component_sub_type=None,
                 component_type=None,
                 resource_type='TraceflowObservation',
                 sequence_no=None,
                 timestamp=None,
                 timestamp_micro=None,
                 transport_node_id=None,
                 transport_node_name=None,
                 transport_node_type=None,
                ):
        """
        :type  component_name: :class:`str` or ``None``
        :param component_name: The name of the component that issued the observation.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  component_sub_type: :class:`str` or ``None``
        :param component_sub_type: Possible values are: 
            
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_LR_TIER0`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_LR_TIER1`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_LR_VRF_TIER0`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_LS_TRANSIT`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_SI_CLASSIFIER`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_SI_PROXY`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_VDR`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_ENI`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_AWS_GATEWAY`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_TGW_ROUTE`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_EDGE_UPLINK`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_DELL_GATEWAY`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_UNKNOWN`
            
             The sub type of the component that issued the observation.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  component_type: :class:`str` or ``None``
        :param component_type: Possible values are: 
            
            * :attr:`TraceflowObservation.COMPONENT_TYPE_PHYSICAL`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_LR`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_LS`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_DFW`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_BRIDGE`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_EDGE_TUNNEL`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_EDGE_HOSTSWITCH`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_FW_BRIDGE`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_LOAD_BALANCER`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_NAT`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_IPSEC`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_SERVICE_INSERTION`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_VMC`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_SPOOFGUARD`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_EDGE_FW`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_UNKNOWN`
            
             The type of the component that issued the observation.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONFORWARDED`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONDROPPED`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONDELIVERED`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONRECEIVED`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONFORWARDEDLOGICAL`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONDROPPEDLOGICAL`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONRECEIVEDLOGICAL`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONREPLICATIONLOGICAL`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONRELAYEDLOGICAL`
        :type  sequence_no: :class:`long` or ``None``
        :param sequence_no: the hop count for observations on the transport node that a
            traceflow packet is injected in will be 0. The hop count is
            incremented each time a subsequent transport node receives the
            traceflow packet. The sequence number of 999 indicates that the hop
            count could not be determined for the containing observation.
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  timestamp: :class:`long` or ``None``
        :param timestamp: Timestamp when the observation was created by the transport node
            (milliseconds epoch) format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  timestamp_micro: :class:`long` or ``None``
        :param timestamp_micro: Timestamp when the observation was created by the transport node
            (microseconds epoch) format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  transport_node_id: :class:`str` or ``None``
        :param transport_node_id: id of the transport node that observed a traceflow packet
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  transport_node_name: :class:`str` or ``None``
        :param transport_node_name: name of the transport node that observed a traceflow packet
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  transport_node_type: :class:`str` or ``None``
        :param transport_node_type: Possible values are: 
            
            * :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_ESX`
            * :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_RHELKVM`
            * :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_UBUNTUKVM`
            * :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_EDGE`
            *
              :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_PUBLIC_CLOUD_GATEWAY_NODE`
            * :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_OTHERS`
            * :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_HYPERV`
            
             type of the transport node that observed a traceflow packet
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.component_name = component_name
        self.component_sub_type = component_sub_type
        self.component_type = component_type
        self._resource_type = resource_type
        self.sequence_no = sequence_no
        self.timestamp = timestamp
        self.timestamp_micro = timestamp_micro
        self.transport_node_id = transport_node_id
        self.transport_node_name = transport_node_name
        self.transport_node_type = transport_node_type
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

TraceflowObservation._set_binding_type(type.StructType(
    'com.vmware.nsx.model.traceflow_observation', {
        'component_name': type.OptionalType(type.StringType()),
        'component_sub_type': type.OptionalType(type.StringType()),
        'component_type': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'sequence_no': type.OptionalType(type.IntegerType()),
        'timestamp': type.OptionalType(type.IntegerType()),
        'timestamp_micro': type.OptionalType(type.IntegerType()),
        'transport_node_id': type.OptionalType(type.StringType()),
        'transport_node_name': type.OptionalType(type.StringType()),
        'transport_node_type': type.OptionalType(type.StringType()),
    },
    TraceflowObservation,
    False,
    None))



class TraceflowObservationCounters(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'delivered_count': 'delivered_count',
                            'dropped_count': 'dropped_count',
                            'forwarded_count': 'forwarded_count',
                            'received_count': 'received_count',
                            }

    def __init__(self,
                 delivered_count=None,
                 dropped_count=None,
                 forwarded_count=None,
                 received_count=None,
                ):
        """
        :type  delivered_count: :class:`long` or ``None``
        :param delivered_count: Total number of delivered observations for this traceflow round.
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  dropped_count: :class:`long` or ``None``
        :param dropped_count: Total number of dropped observations for this round. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  forwarded_count: :class:`long` or ``None``
        :param forwarded_count: Total number of forwarded observations for this traceflow round.
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  received_count: :class:`long` or ``None``
        :param received_count: Total number of received observations for this traceflow round.
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.delivered_count = delivered_count
        self.dropped_count = dropped_count
        self.forwarded_count = forwarded_count
        self.received_count = received_count
        VapiStruct.__init__(self)


TraceflowObservationCounters._set_binding_type(type.StructType(
    'com.vmware.nsx.model.traceflow_observation_counters', {
        'delivered_count': type.OptionalType(type.IntegerType()),
        'dropped_count': type.OptionalType(type.IntegerType()),
        'forwarded_count': type.OptionalType(type.IntegerType()),
        'received_count': type.OptionalType(type.IntegerType()),
    },
    TraceflowObservationCounters,
    False,
    None))



class TraceflowObservationDelivered(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "TraceflowObservationDelivered"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    RESOLUTION_TYPE_UNKNOWN = "UNKNOWN"
    """


    """
    RESOLUTION_TYPE_ARP_SUPPRESSION_PORT_CACHE = "ARP_SUPPRESSION_PORT_CACHE"
    """


    """
    RESOLUTION_TYPE_ARP_SUPPRESSION_TABLE = "ARP_SUPPRESSION_TABLE"
    """


    """
    RESOLUTION_TYPE_ARP_SUPPRESSION_CP_QUERY = "ARP_SUPPRESSION_CP_QUERY"
    """


    """
    RESOLUTION_TYPE_ARP_VM = "ARP_VM"
    """


    """



    _canonical_to_pep_names = {
                            'lport_id': 'lport_id',
                            'lport_name': 'lport_name',
                            'resolution_type': 'resolution_type',
                            'target_mac': 'target_mac',
                            'vlan_id': 'vlan_id',
                            'component_name': 'component_name',
                            'component_sub_type': 'component_sub_type',
                            'component_type': 'component_type',
                            'resource_type': 'resource_type',
                            'sequence_no': 'sequence_no',
                            'timestamp': 'timestamp',
                            'timestamp_micro': 'timestamp_micro',
                            'transport_node_id': 'transport_node_id',
                            'transport_node_name': 'transport_node_name',
                            'transport_node_type': 'transport_node_type',
                            }

    def __init__(self,
                 lport_id=None,
                 lport_name=None,
                 resolution_type=None,
                 target_mac=None,
                 vlan_id=None,
                 component_name=None,
                 component_sub_type=None,
                 component_type=None,
                 resource_type='TraceflowObservationDelivered',
                 sequence_no=None,
                 timestamp=None,
                 timestamp_micro=None,
                 transport_node_id=None,
                 transport_node_name=None,
                 transport_node_type=None,
                ):
        """
        :type  lport_id: :class:`str` or ``None``
        :param lport_id: The id of the logical port into which the traceflow packet was
            delivered
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  lport_name: :class:`str` or ``None``
        :param lport_name: The name of the logical port into which the traceflow packet was
            delivered
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  resolution_type: :class:`str` or ``None``
        :param resolution_type: Possible values are: 
            
            * :attr:`TraceflowObservationDelivered.RESOLUTION_TYPE_UNKNOWN`
            *
              :attr:`TraceflowObservationDelivered.RESOLUTION_TYPE_ARP_SUPPRESSION_PORT_CACHE`
            *
              :attr:`TraceflowObservationDelivered.RESOLUTION_TYPE_ARP_SUPPRESSION_TABLE`
            *
              :attr:`TraceflowObservationDelivered.RESOLUTION_TYPE_ARP_SUPPRESSION_CP_QUERY`
            * :attr:`TraceflowObservationDelivered.RESOLUTION_TYPE_ARP_VM`
            
            This field specifies the resolution type of ARP
            ARP_SUPPRESSION_PORT_CACHE - ARP request is suppressed by port DB
            ARP_SUPPRESSION_TABLE - ARP request is suppressed by ARP table
            ARP_SUPPRESSION_CP_QUERY - ARP request is suppressed by info
            derived from CP ARP_VM - No suppression and the ARP request is
            resolved.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  target_mac: :class:`str` or ``None``
        :param target_mac: The source MAC address of form:
            \"^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$\". For example:
            00:00:00:00:00:00.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  vlan_id: :class:`long` or ``None``
        :param vlan_id: VLAN on bridged network format: int64
        :type  component_name: :class:`str` or ``None``
        :param component_name: The name of the component that issued the observation.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  component_sub_type: :class:`str` or ``None``
        :param component_sub_type: Possible values are: 
            
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_LR_TIER0`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_LR_TIER1`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_LR_VRF_TIER0`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_LS_TRANSIT`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_SI_CLASSIFIER`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_SI_PROXY`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_VDR`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_ENI`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_AWS_GATEWAY`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_TGW_ROUTE`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_EDGE_UPLINK`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_DELL_GATEWAY`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_UNKNOWN`
            
             The sub type of the component that issued the observation.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  component_type: :class:`str` or ``None``
        :param component_type: Possible values are: 
            
            * :attr:`TraceflowObservation.COMPONENT_TYPE_PHYSICAL`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_LR`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_LS`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_DFW`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_BRIDGE`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_EDGE_TUNNEL`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_EDGE_HOSTSWITCH`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_FW_BRIDGE`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_LOAD_BALANCER`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_NAT`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_IPSEC`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_SERVICE_INSERTION`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_VMC`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_SPOOFGUARD`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_EDGE_FW`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_UNKNOWN`
            
             The type of the component that issued the observation.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONFORWARDED`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONDROPPED`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONDELIVERED`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONRECEIVED`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONFORWARDEDLOGICAL`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONDROPPEDLOGICAL`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONRECEIVEDLOGICAL`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONREPLICATIONLOGICAL`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONRELAYEDLOGICAL`
        :type  sequence_no: :class:`long` or ``None``
        :param sequence_no: the hop count for observations on the transport node that a
            traceflow packet is injected in will be 0. The hop count is
            incremented each time a subsequent transport node receives the
            traceflow packet. The sequence number of 999 indicates that the hop
            count could not be determined for the containing observation.
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  timestamp: :class:`long` or ``None``
        :param timestamp: Timestamp when the observation was created by the transport node
            (milliseconds epoch) format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  timestamp_micro: :class:`long` or ``None``
        :param timestamp_micro: Timestamp when the observation was created by the transport node
            (microseconds epoch) format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  transport_node_id: :class:`str` or ``None``
        :param transport_node_id: id of the transport node that observed a traceflow packet
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  transport_node_name: :class:`str` or ``None``
        :param transport_node_name: name of the transport node that observed a traceflow packet
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  transport_node_type: :class:`str` or ``None``
        :param transport_node_type: Possible values are: 
            
            * :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_ESX`
            * :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_RHELKVM`
            * :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_UBUNTUKVM`
            * :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_EDGE`
            *
              :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_PUBLIC_CLOUD_GATEWAY_NODE`
            * :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_OTHERS`
            * :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_HYPERV`
            
             type of the transport node that observed a traceflow packet
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.lport_id = lport_id
        self.lport_name = lport_name
        self.resolution_type = resolution_type
        self.target_mac = target_mac
        self.vlan_id = vlan_id
        self.component_name = component_name
        self.component_sub_type = component_sub_type
        self.component_type = component_type
        self._resource_type = resource_type
        self.sequence_no = sequence_no
        self.timestamp = timestamp
        self.timestamp_micro = timestamp_micro
        self.transport_node_id = transport_node_id
        self.transport_node_name = transport_node_name
        self.transport_node_type = transport_node_type
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

TraceflowObservationDelivered._set_binding_type(type.StructType(
    'com.vmware.nsx.model.traceflow_observation_delivered', {
        'lport_id': type.OptionalType(type.StringType()),
        'lport_name': type.OptionalType(type.StringType()),
        'resolution_type': type.OptionalType(type.StringType()),
        'target_mac': type.OptionalType(type.StringType()),
        'vlan_id': type.OptionalType(type.IntegerType()),
        'component_name': type.OptionalType(type.StringType()),
        'component_sub_type': type.OptionalType(type.StringType()),
        'component_type': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'sequence_no': type.OptionalType(type.IntegerType()),
        'timestamp': type.OptionalType(type.IntegerType()),
        'timestamp_micro': type.OptionalType(type.IntegerType()),
        'transport_node_id': type.OptionalType(type.StringType()),
        'transport_node_name': type.OptionalType(type.StringType()),
        'transport_node_type': type.OptionalType(type.StringType()),
    },
    TraceflowObservationDelivered,
    False,
    None))



class TraceflowObservationDropped(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "TraceflowObservationDropped"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    ARP_FAIL_REASON_UNKNOWN = "ARP_UNKNOWN"
    """


    """
    ARP_FAIL_REASON_TIMEOUT = "ARP_TIMEOUT"
    """


    """
    ARP_FAIL_REASON_CPFAIL = "ARP_CPFAIL"
    """


    """
    ARP_FAIL_REASON_FROMCP = "ARP_FROMCP"
    """


    """
    ARP_FAIL_REASON_PORTDESTROY = "ARP_PORTDESTROY"
    """


    """
    ARP_FAIL_REASON_TABLEDESTROY = "ARP_TABLEDESTROY"
    """


    """
    ARP_FAIL_REASON_NETDESTROY = "ARP_NETDESTROY"
    """


    """
    REASON_ARP_FAIL = "ARP_FAIL"
    """


    """
    REASON_BFD = "BFD"
    """


    """
    REASON_DHCP = "DHCP"
    """


    """
    REASON_FW_RULE = "FW_RULE"
    """


    """
    REASON_GENEVE = "GENEVE"
    """


    """
    REASON_GRE = "GRE"
    """


    """
    REASON_IFACE = "IFACE"
    """


    """
    REASON_IP = "IP"
    """


    """
    REASON_IP_REASS = "IP_REASS"
    """


    """
    REASON_IPSEC = "IPSEC"
    """


    """
    REASON_IPSEC_VTI = "IPSEC_VTI"
    """


    """
    REASON_L2VPN = "L2VPN"
    """


    """
    REASON_L4PORT = "L4PORT"
    """


    """
    REASON_LB = "LB"
    """


    """
    REASON_LROUTER = "LROUTER"
    """


    """
    REASON_LSERVICE = "LSERVICE"
    """


    """
    REASON_LSWITCH = "LSWITCH"
    """


    """
    REASON_MD_PROXY = "MD_PROXY"
    """


    """
    REASON_NAT = "NAT"
    """


    """
    REASON_ND_NS_FAIL = "ND_NS_FAIL"
    """


    """
    REASON_NEIGH = "NEIGH"
    """


    """
    REASON_NO_EIP_FOUND = "NO_EIP_FOUND"
    """


    """
    REASON_NO_EIP_ASSOCIATION = "NO_EIP_ASSOCIATION"
    """


    """
    REASON_NO_ENI_FOR_IP = "NO_ENI_FOR_IP"
    """


    """
    REASON_NO_ENI_FOR_LIF = "NO_ENI_FOR_LIF"
    """


    """
    REASON_NO_ROUTE = "NO_ROUTE"
    """


    """
    REASON_NO_ROUTE_TABLE_FOUND = "NO_ROUTE_TABLE_FOUND"
    """


    """
    REASON_NO_UNDERLAY_ROUTE_FOUND = "NO_UNDERLAY_ROUTE_FOUND"
    """


    """
    REASON_NOT_VDR_DOWNLINK_ = "NOT_VDR_DOWNLINK,"
    """


    """
    REASON_NO_VDR_FOUND = "NO_VDR_FOUND"
    """


    """
    REASON_NO_VDR_ON_HOST = "NO_VDR_ON_HOST"
    """


    """
    REASON_NOT_VDR_UPLINK_ = "NOT_VDR_UPLINK,"
    """


    """
    REASON_SERVICE_INSERT = "SERVICE_INSERT"
    """


    """
    REASON_SPOOFGUARD = "SPOOFGUARD"
    """


    """
    REASON_TTL_ZERO = "TTL_ZERO"
    """


    """
    REASON_TUNNEL = "TUNNEL"
    """


    """
    REASON_VXLAN = "VXLAN"
    """


    """
    REASON_VXSTT = "VXSTT"
    """


    """
    REASON_VMC_NO_RESPONSE = "VMC_NO_RESPONSE"
    """


    """
    REASON_WRONG_UPLINK = "WRONG_UPLINK"
    """


    """
    REASON_UNKNOWN = "UNKNOWN"
    """


    """



    _canonical_to_pep_names = {
                            'acl_rule_id': 'acl_rule_id',
                            'arp_fail_reason': 'arp_fail_reason',
                            'lport_id': 'lport_id',
                            'lport_name': 'lport_name',
                            'nat_rule_id': 'nat_rule_id',
                            'reason': 'reason',
                            'component_name': 'component_name',
                            'component_sub_type': 'component_sub_type',
                            'component_type': 'component_type',
                            'resource_type': 'resource_type',
                            'sequence_no': 'sequence_no',
                            'timestamp': 'timestamp',
                            'timestamp_micro': 'timestamp_micro',
                            'transport_node_id': 'transport_node_id',
                            'transport_node_name': 'transport_node_name',
                            'transport_node_type': 'transport_node_type',
                            }

    def __init__(self,
                 acl_rule_id=None,
                 arp_fail_reason=None,
                 lport_id=None,
                 lport_name=None,
                 nat_rule_id=None,
                 reason=None,
                 component_name=None,
                 component_sub_type=None,
                 component_type=None,
                 resource_type='TraceflowObservationDropped',
                 sequence_no=None,
                 timestamp=None,
                 timestamp_micro=None,
                 transport_node_id=None,
                 transport_node_name=None,
                 transport_node_type=None,
                ):
        """
        :type  acl_rule_id: :class:`long` or ``None``
        :param acl_rule_id: The id of the acl rule that was applied to drop the traceflow
            packet format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  arp_fail_reason: :class:`str` or ``None``
        :param arp_fail_reason: Possible values are: 
            
            * :attr:`TraceflowObservationDropped.ARP_FAIL_REASON_UNKNOWN`
            * :attr:`TraceflowObservationDropped.ARP_FAIL_REASON_TIMEOUT`
            * :attr:`TraceflowObservationDropped.ARP_FAIL_REASON_CPFAIL`
            * :attr:`TraceflowObservationDropped.ARP_FAIL_REASON_FROMCP`
            * :attr:`TraceflowObservationDropped.ARP_FAIL_REASON_PORTDESTROY`
            * :attr:`TraceflowObservationDropped.ARP_FAIL_REASON_TABLEDESTROY`
            * :attr:`TraceflowObservationDropped.ARP_FAIL_REASON_NETDESTROY`
            
            This field specifies the ARP fails reason ARP_TIMEOUT - ARP failure
            due to query control plane timeout ARP_CPFAIL - ARP failure due
            post ARP query message to control plane failure ARP_FROMCP - ARP
            failure due to deleting ARP entry from control plane
            ARP_PORTDESTROY - ARP failure due to port destruction
            ARP_TABLEDESTROY - ARP failure due to ARP table destruction
            ARP_NETDESTROY - ARP failure due to overlay network destruction
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  lport_id: :class:`str` or ``None``
        :param lport_id: The id of the logical port at which the traceflow packet was
            dropped
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  lport_name: :class:`str` or ``None``
        :param lport_name: The name of the logical port at which the traceflow packet was
            dropped
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  nat_rule_id: :class:`long` or ``None``
        :param nat_rule_id: The ID of the NAT rule that was applied to forward the traceflow
            packet format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  reason: :class:`str` or ``None``
        :param reason: Possible values are: 
            
            * :attr:`TraceflowObservationDropped.REASON_ARP_FAIL`
            * :attr:`TraceflowObservationDropped.REASON_BFD`
            * :attr:`TraceflowObservationDropped.REASON_DHCP`
            * :attr:`TraceflowObservationDropped.REASON_FW_RULE`
            * :attr:`TraceflowObservationDropped.REASON_GENEVE`
            * :attr:`TraceflowObservationDropped.REASON_GRE`
            * :attr:`TraceflowObservationDropped.REASON_IFACE`
            * :attr:`TraceflowObservationDropped.REASON_IP`
            * :attr:`TraceflowObservationDropped.REASON_IP_REASS`
            * :attr:`TraceflowObservationDropped.REASON_IPSEC`
            * :attr:`TraceflowObservationDropped.REASON_IPSEC_VTI`
            * :attr:`TraceflowObservationDropped.REASON_L2VPN`
            * :attr:`TraceflowObservationDropped.REASON_L4PORT`
            * :attr:`TraceflowObservationDropped.REASON_LB`
            * :attr:`TraceflowObservationDropped.REASON_LROUTER`
            * :attr:`TraceflowObservationDropped.REASON_LSERVICE`
            * :attr:`TraceflowObservationDropped.REASON_LSWITCH`
            * :attr:`TraceflowObservationDropped.REASON_MD_PROXY`
            * :attr:`TraceflowObservationDropped.REASON_NAT`
            * :attr:`TraceflowObservationDropped.REASON_ND_NS_FAIL`
            * :attr:`TraceflowObservationDropped.REASON_NEIGH`
            * :attr:`TraceflowObservationDropped.REASON_NO_EIP_FOUND`
            * :attr:`TraceflowObservationDropped.REASON_NO_EIP_ASSOCIATION`
            * :attr:`TraceflowObservationDropped.REASON_NO_ENI_FOR_IP`
            * :attr:`TraceflowObservationDropped.REASON_NO_ENI_FOR_LIF`
            * :attr:`TraceflowObservationDropped.REASON_NO_ROUTE`
            * :attr:`TraceflowObservationDropped.REASON_NO_ROUTE_TABLE_FOUND`
            *
              :attr:`TraceflowObservationDropped.REASON_NO_UNDERLAY_ROUTE_FOUND`
            * :attr:`TraceflowObservationDropped.REASON_NOT_VDR_DOWNLINK_`
            * :attr:`TraceflowObservationDropped.REASON_NO_VDR_FOUND`
            * :attr:`TraceflowObservationDropped.REASON_NO_VDR_ON_HOST`
            * :attr:`TraceflowObservationDropped.REASON_NOT_VDR_UPLINK_`
            * :attr:`TraceflowObservationDropped.REASON_SERVICE_INSERT`
            * :attr:`TraceflowObservationDropped.REASON_SPOOFGUARD`
            * :attr:`TraceflowObservationDropped.REASON_TTL_ZERO`
            * :attr:`TraceflowObservationDropped.REASON_TUNNEL`
            * :attr:`TraceflowObservationDropped.REASON_VXLAN`
            * :attr:`TraceflowObservationDropped.REASON_VXSTT`
            * :attr:`TraceflowObservationDropped.REASON_VMC_NO_RESPONSE`
            * :attr:`TraceflowObservationDropped.REASON_WRONG_UPLINK`
            * :attr:`TraceflowObservationDropped.REASON_UNKNOWN`
            
             The reason traceflow packet was dropped
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  component_name: :class:`str` or ``None``
        :param component_name: The name of the component that issued the observation.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  component_sub_type: :class:`str` or ``None``
        :param component_sub_type: Possible values are: 
            
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_LR_TIER0`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_LR_TIER1`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_LR_VRF_TIER0`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_LS_TRANSIT`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_SI_CLASSIFIER`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_SI_PROXY`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_VDR`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_ENI`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_AWS_GATEWAY`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_TGW_ROUTE`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_EDGE_UPLINK`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_DELL_GATEWAY`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_UNKNOWN`
            
             The sub type of the component that issued the observation.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  component_type: :class:`str` or ``None``
        :param component_type: Possible values are: 
            
            * :attr:`TraceflowObservation.COMPONENT_TYPE_PHYSICAL`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_LR`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_LS`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_DFW`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_BRIDGE`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_EDGE_TUNNEL`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_EDGE_HOSTSWITCH`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_FW_BRIDGE`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_LOAD_BALANCER`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_NAT`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_IPSEC`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_SERVICE_INSERTION`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_VMC`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_SPOOFGUARD`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_EDGE_FW`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_UNKNOWN`
            
             The type of the component that issued the observation.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONFORWARDED`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONDROPPED`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONDELIVERED`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONRECEIVED`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONFORWARDEDLOGICAL`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONDROPPEDLOGICAL`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONRECEIVEDLOGICAL`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONREPLICATIONLOGICAL`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONRELAYEDLOGICAL`
        :type  sequence_no: :class:`long` or ``None``
        :param sequence_no: the hop count for observations on the transport node that a
            traceflow packet is injected in will be 0. The hop count is
            incremented each time a subsequent transport node receives the
            traceflow packet. The sequence number of 999 indicates that the hop
            count could not be determined for the containing observation.
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  timestamp: :class:`long` or ``None``
        :param timestamp: Timestamp when the observation was created by the transport node
            (milliseconds epoch) format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  timestamp_micro: :class:`long` or ``None``
        :param timestamp_micro: Timestamp when the observation was created by the transport node
            (microseconds epoch) format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  transport_node_id: :class:`str` or ``None``
        :param transport_node_id: id of the transport node that observed a traceflow packet
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  transport_node_name: :class:`str` or ``None``
        :param transport_node_name: name of the transport node that observed a traceflow packet
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  transport_node_type: :class:`str` or ``None``
        :param transport_node_type: Possible values are: 
            
            * :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_ESX`
            * :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_RHELKVM`
            * :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_UBUNTUKVM`
            * :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_EDGE`
            *
              :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_PUBLIC_CLOUD_GATEWAY_NODE`
            * :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_OTHERS`
            * :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_HYPERV`
            
             type of the transport node that observed a traceflow packet
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.acl_rule_id = acl_rule_id
        self.arp_fail_reason = arp_fail_reason
        self.lport_id = lport_id
        self.lport_name = lport_name
        self.nat_rule_id = nat_rule_id
        self.reason = reason
        self.component_name = component_name
        self.component_sub_type = component_sub_type
        self.component_type = component_type
        self._resource_type = resource_type
        self.sequence_no = sequence_no
        self.timestamp = timestamp
        self.timestamp_micro = timestamp_micro
        self.transport_node_id = transport_node_id
        self.transport_node_name = transport_node_name
        self.transport_node_type = transport_node_type
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

TraceflowObservationDropped._set_binding_type(type.StructType(
    'com.vmware.nsx.model.traceflow_observation_dropped', {
        'acl_rule_id': type.OptionalType(type.IntegerType()),
        'arp_fail_reason': type.OptionalType(type.StringType()),
        'lport_id': type.OptionalType(type.StringType()),
        'lport_name': type.OptionalType(type.StringType()),
        'nat_rule_id': type.OptionalType(type.IntegerType()),
        'reason': type.OptionalType(type.StringType()),
        'component_name': type.OptionalType(type.StringType()),
        'component_sub_type': type.OptionalType(type.StringType()),
        'component_type': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'sequence_no': type.OptionalType(type.IntegerType()),
        'timestamp': type.OptionalType(type.IntegerType()),
        'timestamp_micro': type.OptionalType(type.IntegerType()),
        'transport_node_id': type.OptionalType(type.StringType()),
        'transport_node_name': type.OptionalType(type.StringType()),
        'transport_node_type': type.OptionalType(type.StringType()),
    },
    TraceflowObservationDropped,
    False,
    None))



class TraceflowObservationDroppedLogical(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'component_id': 'component_id',
                            'service_path_index': 'service_path_index',
                            'acl_rule_id': 'acl_rule_id',
                            'arp_fail_reason': 'arp_fail_reason',
                            'lport_id': 'lport_id',
                            'lport_name': 'lport_name',
                            'nat_rule_id': 'nat_rule_id',
                            'reason': 'reason',
                            'component_name': 'component_name',
                            'component_sub_type': 'component_sub_type',
                            'component_type': 'component_type',
                            'resource_type': 'resource_type',
                            'sequence_no': 'sequence_no',
                            'timestamp': 'timestamp',
                            'timestamp_micro': 'timestamp_micro',
                            'transport_node_id': 'transport_node_id',
                            'transport_node_name': 'transport_node_name',
                            'transport_node_type': 'transport_node_type',
                            }

    def __init__(self,
                 component_id=None,
                 service_path_index=None,
                 acl_rule_id=None,
                 arp_fail_reason=None,
                 lport_id=None,
                 lport_name=None,
                 nat_rule_id=None,
                 reason=None,
                 component_name=None,
                 component_sub_type=None,
                 component_type=None,
                 resource_type=None,
                 sequence_no=None,
                 timestamp=None,
                 timestamp_micro=None,
                 transport_node_id=None,
                 transport_node_name=None,
                 transport_node_type=None,
                ):
        """
        :type  component_id: :class:`str` or ``None``
        :param component_id: The id of the component that dropped the traceflow packet.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  service_path_index: :class:`long` or ``None``
        :param service_path_index: The index of service path that is a chain of services represents
            the point where the traceflow packet was dropped. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  acl_rule_id: :class:`long` or ``None``
        :param acl_rule_id: The id of the acl rule that was applied to drop the traceflow
            packet format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  arp_fail_reason: :class:`str` or ``None``
        :param arp_fail_reason: Possible values are: 
            
            * :attr:`TraceflowObservationDropped.ARP_FAIL_REASON_UNKNOWN`
            * :attr:`TraceflowObservationDropped.ARP_FAIL_REASON_TIMEOUT`
            * :attr:`TraceflowObservationDropped.ARP_FAIL_REASON_CPFAIL`
            * :attr:`TraceflowObservationDropped.ARP_FAIL_REASON_FROMCP`
            * :attr:`TraceflowObservationDropped.ARP_FAIL_REASON_PORTDESTROY`
            * :attr:`TraceflowObservationDropped.ARP_FAIL_REASON_TABLEDESTROY`
            * :attr:`TraceflowObservationDropped.ARP_FAIL_REASON_NETDESTROY`
            
            This field specifies the ARP fails reason ARP_TIMEOUT - ARP failure
            due to query control plane timeout ARP_CPFAIL - ARP failure due
            post ARP query message to control plane failure ARP_FROMCP - ARP
            failure due to deleting ARP entry from control plane
            ARP_PORTDESTROY - ARP failure due to port destruction
            ARP_TABLEDESTROY - ARP failure due to ARP table destruction
            ARP_NETDESTROY - ARP failure due to overlay network destruction
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  lport_id: :class:`str` or ``None``
        :param lport_id: The id of the logical port at which the traceflow packet was
            dropped
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  lport_name: :class:`str` or ``None``
        :param lport_name: The name of the logical port at which the traceflow packet was
            dropped
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  nat_rule_id: :class:`long` or ``None``
        :param nat_rule_id: The ID of the NAT rule that was applied to forward the traceflow
            packet format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  reason: :class:`str` or ``None``
        :param reason: Possible values are: 
            
            * :attr:`TraceflowObservationDropped.REASON_ARP_FAIL`
            * :attr:`TraceflowObservationDropped.REASON_BFD`
            * :attr:`TraceflowObservationDropped.REASON_DHCP`
            * :attr:`TraceflowObservationDropped.REASON_FW_RULE`
            * :attr:`TraceflowObservationDropped.REASON_GENEVE`
            * :attr:`TraceflowObservationDropped.REASON_GRE`
            * :attr:`TraceflowObservationDropped.REASON_IFACE`
            * :attr:`TraceflowObservationDropped.REASON_IP`
            * :attr:`TraceflowObservationDropped.REASON_IP_REASS`
            * :attr:`TraceflowObservationDropped.REASON_IPSEC`
            * :attr:`TraceflowObservationDropped.REASON_IPSEC_VTI`
            * :attr:`TraceflowObservationDropped.REASON_L2VPN`
            * :attr:`TraceflowObservationDropped.REASON_L4PORT`
            * :attr:`TraceflowObservationDropped.REASON_LB`
            * :attr:`TraceflowObservationDropped.REASON_LROUTER`
            * :attr:`TraceflowObservationDropped.REASON_LSERVICE`
            * :attr:`TraceflowObservationDropped.REASON_LSWITCH`
            * :attr:`TraceflowObservationDropped.REASON_MD_PROXY`
            * :attr:`TraceflowObservationDropped.REASON_NAT`
            * :attr:`TraceflowObservationDropped.REASON_ND_NS_FAIL`
            * :attr:`TraceflowObservationDropped.REASON_NEIGH`
            * :attr:`TraceflowObservationDropped.REASON_NO_EIP_FOUND`
            * :attr:`TraceflowObservationDropped.REASON_NO_EIP_ASSOCIATION`
            * :attr:`TraceflowObservationDropped.REASON_NO_ENI_FOR_IP`
            * :attr:`TraceflowObservationDropped.REASON_NO_ENI_FOR_LIF`
            * :attr:`TraceflowObservationDropped.REASON_NO_ROUTE`
            * :attr:`TraceflowObservationDropped.REASON_NO_ROUTE_TABLE_FOUND`
            *
              :attr:`TraceflowObservationDropped.REASON_NO_UNDERLAY_ROUTE_FOUND`
            * :attr:`TraceflowObservationDropped.REASON_NOT_VDR_DOWNLINK_`
            * :attr:`TraceflowObservationDropped.REASON_NO_VDR_FOUND`
            * :attr:`TraceflowObservationDropped.REASON_NO_VDR_ON_HOST`
            * :attr:`TraceflowObservationDropped.REASON_NOT_VDR_UPLINK_`
            * :attr:`TraceflowObservationDropped.REASON_SERVICE_INSERT`
            * :attr:`TraceflowObservationDropped.REASON_SPOOFGUARD`
            * :attr:`TraceflowObservationDropped.REASON_TTL_ZERO`
            * :attr:`TraceflowObservationDropped.REASON_TUNNEL`
            * :attr:`TraceflowObservationDropped.REASON_VXLAN`
            * :attr:`TraceflowObservationDropped.REASON_VXSTT`
            * :attr:`TraceflowObservationDropped.REASON_VMC_NO_RESPONSE`
            * :attr:`TraceflowObservationDropped.REASON_WRONG_UPLINK`
            * :attr:`TraceflowObservationDropped.REASON_UNKNOWN`
            
             The reason traceflow packet was dropped
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  component_name: :class:`str` or ``None``
        :param component_name: The name of the component that issued the observation.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  component_sub_type: :class:`str` or ``None``
        :param component_sub_type: Possible values are: 
            
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_LR_TIER0`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_LR_TIER1`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_LR_VRF_TIER0`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_LS_TRANSIT`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_SI_CLASSIFIER`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_SI_PROXY`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_VDR`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_ENI`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_AWS_GATEWAY`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_TGW_ROUTE`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_EDGE_UPLINK`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_DELL_GATEWAY`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_UNKNOWN`
            
             The sub type of the component that issued the observation.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  component_type: :class:`str` or ``None``
        :param component_type: Possible values are: 
            
            * :attr:`TraceflowObservation.COMPONENT_TYPE_PHYSICAL`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_LR`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_LS`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_DFW`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_BRIDGE`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_EDGE_TUNNEL`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_EDGE_HOSTSWITCH`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_FW_BRIDGE`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_LOAD_BALANCER`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_NAT`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_IPSEC`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_SERVICE_INSERTION`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_VMC`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_SPOOFGUARD`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_EDGE_FW`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_UNKNOWN`
            
             The type of the component that issued the observation.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONFORWARDED`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONDROPPED`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONDELIVERED`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONRECEIVED`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONFORWARDEDLOGICAL`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONDROPPEDLOGICAL`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONRECEIVEDLOGICAL`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONREPLICATIONLOGICAL`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONRELAYEDLOGICAL`
        :type  sequence_no: :class:`long` or ``None``
        :param sequence_no: the hop count for observations on the transport node that a
            traceflow packet is injected in will be 0. The hop count is
            incremented each time a subsequent transport node receives the
            traceflow packet. The sequence number of 999 indicates that the hop
            count could not be determined for the containing observation.
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  timestamp: :class:`long` or ``None``
        :param timestamp: Timestamp when the observation was created by the transport node
            (milliseconds epoch) format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  timestamp_micro: :class:`long` or ``None``
        :param timestamp_micro: Timestamp when the observation was created by the transport node
            (microseconds epoch) format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  transport_node_id: :class:`str` or ``None``
        :param transport_node_id: id of the transport node that observed a traceflow packet
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  transport_node_name: :class:`str` or ``None``
        :param transport_node_name: name of the transport node that observed a traceflow packet
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  transport_node_type: :class:`str` or ``None``
        :param transport_node_type: Possible values are: 
            
            * :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_ESX`
            * :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_RHELKVM`
            * :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_UBUNTUKVM`
            * :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_EDGE`
            *
              :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_PUBLIC_CLOUD_GATEWAY_NODE`
            * :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_OTHERS`
            * :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_HYPERV`
            
             type of the transport node that observed a traceflow packet
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.component_id = component_id
        self.service_path_index = service_path_index
        self.acl_rule_id = acl_rule_id
        self.arp_fail_reason = arp_fail_reason
        self.lport_id = lport_id
        self.lport_name = lport_name
        self.nat_rule_id = nat_rule_id
        self.reason = reason
        self.component_name = component_name
        self.component_sub_type = component_sub_type
        self.component_type = component_type
        self._resource_type = resource_type
        self.sequence_no = sequence_no
        self.timestamp = timestamp
        self.timestamp_micro = timestamp_micro
        self.transport_node_id = transport_node_id
        self.transport_node_name = transport_node_name
        self.transport_node_type = transport_node_type
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

TraceflowObservationDroppedLogical._set_binding_type(type.StructType(
    'com.vmware.nsx.model.traceflow_observation_dropped_logical', {
        'component_id': type.OptionalType(type.StringType()),
        'service_path_index': type.OptionalType(type.IntegerType()),
        'acl_rule_id': type.OptionalType(type.IntegerType()),
        'arp_fail_reason': type.OptionalType(type.StringType()),
        'lport_id': type.OptionalType(type.StringType()),
        'lport_name': type.OptionalType(type.StringType()),
        'nat_rule_id': type.OptionalType(type.IntegerType()),
        'reason': type.OptionalType(type.StringType()),
        'component_name': type.OptionalType(type.StringType()),
        'component_sub_type': type.OptionalType(type.StringType()),
        'component_type': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'sequence_no': type.OptionalType(type.IntegerType()),
        'timestamp': type.OptionalType(type.IntegerType()),
        'timestamp_micro': type.OptionalType(type.IntegerType()),
        'transport_node_id': type.OptionalType(type.StringType()),
        'transport_node_name': type.OptionalType(type.StringType()),
        'transport_node_type': type.OptionalType(type.StringType()),
    },
    TraceflowObservationDroppedLogical,
    False,
    None))



class TraceflowObservationForwarded(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "TraceflowObservationForwarded"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'context': 'context',
                            'dst_transport_node_id': 'dst_transport_node_id',
                            'dst_transport_node_name': 'dst_transport_node_name',
                            'local_ip_address': 'local_ip_address',
                            'remote_ip_address': 'remote_ip_address',
                            'uplink_name': 'uplink_name',
                            'vtep_label': 'vtep_label',
                            'component_name': 'component_name',
                            'component_sub_type': 'component_sub_type',
                            'component_type': 'component_type',
                            'resource_type': 'resource_type',
                            'sequence_no': 'sequence_no',
                            'timestamp': 'timestamp',
                            'timestamp_micro': 'timestamp_micro',
                            'transport_node_id': 'transport_node_id',
                            'transport_node_name': 'transport_node_name',
                            'transport_node_type': 'transport_node_type',
                            }

    def __init__(self,
                 context=None,
                 dst_transport_node_id=None,
                 dst_transport_node_name=None,
                 local_ip_address=None,
                 remote_ip_address=None,
                 uplink_name=None,
                 vtep_label=None,
                 component_name=None,
                 component_sub_type=None,
                 component_type=None,
                 resource_type='TraceflowObservationForwarded',
                 sequence_no=None,
                 timestamp=None,
                 timestamp_micro=None,
                 transport_node_id=None,
                 transport_node_name=None,
                 transport_node_type=None,
                ):
        """
        :type  context: :class:`long` or ``None``
        :param context: The 64bit tunnel context carried on the wire format: int64
        :type  dst_transport_node_id: :class:`str` or ``None``
        :param dst_transport_node_id: This field will not be always available. Use remote_ip_address when
            this field is not set.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  dst_transport_node_name: :class:`str` or ``None``
        :param dst_transport_node_name: The name of the transport node to which the traceflow packet is
            forwarded
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  local_ip_address: :class:`str` or ``None``
        :param local_ip_address: IP address of the source end of the tunnel format: ip
        :type  remote_ip_address: :class:`str` or ``None``
        :param remote_ip_address: IP address of the destination end of the tunnel format: ip
        :type  uplink_name: :class:`str` or ``None``
        :param uplink_name: The name of the uplink the traceflow packet is forwarded on
        :type  vtep_label: :class:`long` or ``None``
        :param vtep_label: The virtual tunnel endpoint label format: int64
        :type  component_name: :class:`str` or ``None``
        :param component_name: The name of the component that issued the observation.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  component_sub_type: :class:`str` or ``None``
        :param component_sub_type: Possible values are: 
            
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_LR_TIER0`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_LR_TIER1`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_LR_VRF_TIER0`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_LS_TRANSIT`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_SI_CLASSIFIER`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_SI_PROXY`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_VDR`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_ENI`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_AWS_GATEWAY`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_TGW_ROUTE`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_EDGE_UPLINK`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_DELL_GATEWAY`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_UNKNOWN`
            
             The sub type of the component that issued the observation.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  component_type: :class:`str` or ``None``
        :param component_type: Possible values are: 
            
            * :attr:`TraceflowObservation.COMPONENT_TYPE_PHYSICAL`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_LR`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_LS`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_DFW`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_BRIDGE`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_EDGE_TUNNEL`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_EDGE_HOSTSWITCH`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_FW_BRIDGE`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_LOAD_BALANCER`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_NAT`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_IPSEC`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_SERVICE_INSERTION`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_VMC`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_SPOOFGUARD`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_EDGE_FW`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_UNKNOWN`
            
             The type of the component that issued the observation.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONFORWARDED`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONDROPPED`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONDELIVERED`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONRECEIVED`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONFORWARDEDLOGICAL`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONDROPPEDLOGICAL`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONRECEIVEDLOGICAL`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONREPLICATIONLOGICAL`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONRELAYEDLOGICAL`
        :type  sequence_no: :class:`long` or ``None``
        :param sequence_no: the hop count for observations on the transport node that a
            traceflow packet is injected in will be 0. The hop count is
            incremented each time a subsequent transport node receives the
            traceflow packet. The sequence number of 999 indicates that the hop
            count could not be determined for the containing observation.
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  timestamp: :class:`long` or ``None``
        :param timestamp: Timestamp when the observation was created by the transport node
            (milliseconds epoch) format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  timestamp_micro: :class:`long` or ``None``
        :param timestamp_micro: Timestamp when the observation was created by the transport node
            (microseconds epoch) format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  transport_node_id: :class:`str` or ``None``
        :param transport_node_id: id of the transport node that observed a traceflow packet
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  transport_node_name: :class:`str` or ``None``
        :param transport_node_name: name of the transport node that observed a traceflow packet
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  transport_node_type: :class:`str` or ``None``
        :param transport_node_type: Possible values are: 
            
            * :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_ESX`
            * :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_RHELKVM`
            * :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_UBUNTUKVM`
            * :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_EDGE`
            *
              :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_PUBLIC_CLOUD_GATEWAY_NODE`
            * :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_OTHERS`
            * :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_HYPERV`
            
             type of the transport node that observed a traceflow packet
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.context = context
        self.dst_transport_node_id = dst_transport_node_id
        self.dst_transport_node_name = dst_transport_node_name
        self.local_ip_address = local_ip_address
        self.remote_ip_address = remote_ip_address
        self.uplink_name = uplink_name
        self.vtep_label = vtep_label
        self.component_name = component_name
        self.component_sub_type = component_sub_type
        self.component_type = component_type
        self._resource_type = resource_type
        self.sequence_no = sequence_no
        self.timestamp = timestamp
        self.timestamp_micro = timestamp_micro
        self.transport_node_id = transport_node_id
        self.transport_node_name = transport_node_name
        self.transport_node_type = transport_node_type
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

TraceflowObservationForwarded._set_binding_type(type.StructType(
    'com.vmware.nsx.model.traceflow_observation_forwarded', {
        'context': type.OptionalType(type.IntegerType()),
        'dst_transport_node_id': type.OptionalType(type.StringType()),
        'dst_transport_node_name': type.OptionalType(type.StringType()),
        'local_ip_address': type.OptionalType(type.StringType()),
        'remote_ip_address': type.OptionalType(type.StringType()),
        'uplink_name': type.OptionalType(type.StringType()),
        'vtep_label': type.OptionalType(type.IntegerType()),
        'component_name': type.OptionalType(type.StringType()),
        'component_sub_type': type.OptionalType(type.StringType()),
        'component_type': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'sequence_no': type.OptionalType(type.IntegerType()),
        'timestamp': type.OptionalType(type.IntegerType()),
        'timestamp_micro': type.OptionalType(type.IntegerType()),
        'transport_node_id': type.OptionalType(type.StringType()),
        'transport_node_name': type.OptionalType(type.StringType()),
        'transport_node_type': type.OptionalType(type.StringType()),
    },
    TraceflowObservationForwarded,
    False,
    None))



class TraceflowObservationForwardedLogical(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "TraceflowObservationForwardedLogical"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    DST_COMPONENT_TYPE_PHYSICAL = "PHYSICAL"
    """


    """
    DST_COMPONENT_TYPE_LR = "LR"
    """


    """
    DST_COMPONENT_TYPE_LS = "LS"
    """


    """
    DST_COMPONENT_TYPE_DFW = "DFW"
    """


    """
    DST_COMPONENT_TYPE_BRIDGE = "BRIDGE"
    """


    """
    DST_COMPONENT_TYPE_EDGE_TUNNEL = "EDGE_TUNNEL"
    """


    """
    DST_COMPONENT_TYPE_EDGE_HOSTSWITCH = "EDGE_HOSTSWITCH"
    """


    """
    DST_COMPONENT_TYPE_FW_BRIDGE = "FW_BRIDGE"
    """


    """
    DST_COMPONENT_TYPE_LOAD_BALANCER = "LOAD_BALANCER"
    """


    """
    DST_COMPONENT_TYPE_NAT = "NAT"
    """


    """
    DST_COMPONENT_TYPE_IPSEC = "IPSEC"
    """


    """
    DST_COMPONENT_TYPE_SERVICE_INSERTION = "SERVICE_INSERTION"
    """


    """
    DST_COMPONENT_TYPE_VMC = "VMC"
    """


    """
    DST_COMPONENT_TYPE_SPOOFGUARD = "SPOOFGUARD"
    """


    """
    DST_COMPONENT_TYPE_EDGE_FW = "EDGE_FW"
    """


    """
    DST_COMPONENT_TYPE_UNKNOWN = "UNKNOWN"
    """


    """
    RESEND_TYPE_UNKNOWN = "UNKNOWN"
    """


    """
    RESEND_TYPE_ARP_UNKNOWN_FROM_CP = "ARP_UNKNOWN_FROM_CP"
    """


    """
    RESEND_TYPE_ND_NS_UNKNWON_FROM_CP = "ND_NS_UNKNWON_FROM_CP"
    """


    """



    _canonical_to_pep_names = {
                            'acl_rule_id': 'acl_rule_id',
                            'component_id': 'component_id',
                            'dst_component_id': 'dst_component_id',
                            'dst_component_name': 'dst_component_name',
                            'dst_component_type': 'dst_component_type',
                            'lport_id': 'lport_id',
                            'lport_name': 'lport_name',
                            'nat_rule_id': 'nat_rule_id',
                            'resend_type': 'resend_type',
                            'service_index': 'service_index',
                            'service_path_index': 'service_path_index',
                            'service_ttl': 'service_ttl',
                            'spoofguard_ip': 'spoofguard_ip',
                            'spoofguard_mac': 'spoofguard_mac',
                            'spoofguard_vlan_id': 'spoofguard_vlan_id',
                            'svc_nh_mac': 'svc_nh_mac',
                            'translated_dst_ip': 'translated_dst_ip',
                            'translated_src_ip': 'translated_src_ip',
                            'vni': 'vni',
                            'component_name': 'component_name',
                            'component_sub_type': 'component_sub_type',
                            'component_type': 'component_type',
                            'resource_type': 'resource_type',
                            'sequence_no': 'sequence_no',
                            'timestamp': 'timestamp',
                            'timestamp_micro': 'timestamp_micro',
                            'transport_node_id': 'transport_node_id',
                            'transport_node_name': 'transport_node_name',
                            'transport_node_type': 'transport_node_type',
                            }

    def __init__(self,
                 acl_rule_id=None,
                 component_id=None,
                 dst_component_id=None,
                 dst_component_name=None,
                 dst_component_type=None,
                 lport_id=None,
                 lport_name=None,
                 nat_rule_id=None,
                 resend_type=None,
                 service_index=None,
                 service_path_index=None,
                 service_ttl=None,
                 spoofguard_ip=None,
                 spoofguard_mac=None,
                 spoofguard_vlan_id=None,
                 svc_nh_mac=None,
                 translated_dst_ip=None,
                 translated_src_ip=None,
                 vni=None,
                 component_name=None,
                 component_sub_type=None,
                 component_type=None,
                 resource_type='TraceflowObservationForwardedLogical',
                 sequence_no=None,
                 timestamp=None,
                 timestamp_micro=None,
                 transport_node_id=None,
                 transport_node_name=None,
                 transport_node_type=None,
                ):
        """
        :type  acl_rule_id: :class:`long` or ``None``
        :param acl_rule_id: The id of the acl rule that was applied to forward the traceflow
            packet format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  component_id: :class:`str` or ``None``
        :param component_id: The id of the component that forwarded the traceflow packet.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  dst_component_id: :class:`str` or ``None``
        :param dst_component_id: The id of the destination component to which the traceflow packet
            was forwarded.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  dst_component_name: :class:`str` or ``None``
        :param dst_component_name: The name of the destination component to which the traceflow packet
            was forwarded.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  dst_component_type: :class:`str` or ``None``
        :param dst_component_type: Possible values are: 
            
            *
              :attr:`TraceflowObservationForwardedLogical.DST_COMPONENT_TYPE_PHYSICAL`
            *
              :attr:`TraceflowObservationForwardedLogical.DST_COMPONENT_TYPE_LR`
            *
              :attr:`TraceflowObservationForwardedLogical.DST_COMPONENT_TYPE_LS`
            *
              :attr:`TraceflowObservationForwardedLogical.DST_COMPONENT_TYPE_DFW`
            *
              :attr:`TraceflowObservationForwardedLogical.DST_COMPONENT_TYPE_BRIDGE`
            *
              :attr:`TraceflowObservationForwardedLogical.DST_COMPONENT_TYPE_EDGE_TUNNEL`
            *
              :attr:`TraceflowObservationForwardedLogical.DST_COMPONENT_TYPE_EDGE_HOSTSWITCH`
            *
              :attr:`TraceflowObservationForwardedLogical.DST_COMPONENT_TYPE_FW_BRIDGE`
            *
              :attr:`TraceflowObservationForwardedLogical.DST_COMPONENT_TYPE_LOAD_BALANCER`
            *
              :attr:`TraceflowObservationForwardedLogical.DST_COMPONENT_TYPE_NAT`
            *
              :attr:`TraceflowObservationForwardedLogical.DST_COMPONENT_TYPE_IPSEC`
            *
              :attr:`TraceflowObservationForwardedLogical.DST_COMPONENT_TYPE_SERVICE_INSERTION`
            *
              :attr:`TraceflowObservationForwardedLogical.DST_COMPONENT_TYPE_VMC`
            *
              :attr:`TraceflowObservationForwardedLogical.DST_COMPONENT_TYPE_SPOOFGUARD`
            *
              :attr:`TraceflowObservationForwardedLogical.DST_COMPONENT_TYPE_EDGE_FW`
            *
              :attr:`TraceflowObservationForwardedLogical.DST_COMPONENT_TYPE_UNKNOWN`
            
            The type of the destination component to which the traceflow packet
            was forwarded.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  lport_id: :class:`str` or ``None``
        :param lport_id: The id of the logical port through which the traceflow packet was
            forwarded.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  lport_name: :class:`str` or ``None``
        :param lport_name: The name of the logical port through which the traceflow packet was
            forwarded.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  nat_rule_id: :class:`long` or ``None``
        :param nat_rule_id: The ID of the NAT rule that was applied to forward the traceflow
            packet format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  resend_type: :class:`str` or ``None``
        :param resend_type: Possible values are: 
            
            * :attr:`TraceflowObservationForwardedLogical.RESEND_TYPE_UNKNOWN`
            *
              :attr:`TraceflowObservationForwardedLogical.RESEND_TYPE_ARP_UNKNOWN_FROM_CP`
            *
              :attr:`TraceflowObservationForwardedLogical.RESEND_TYPE_ND_NS_UNKNWON_FROM_CP`
            
            ARP_UNKNOWN_FROM_CP - Unknown ARP query result emitted by control
            plane ND_NS_UNKNOWN_FROM_CP - Unknown neighbor solicitation query
            result emitted by control plane UNKNOWN - Unknown resend type
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  service_index: :class:`long` or ``None``
        :param service_index: The index of the service insertion component format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  service_path_index: :class:`long` or ``None``
        :param service_path_index: The path index of the service insertion component format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  service_ttl: :class:`long` or ``None``
        :param service_ttl: The ttl of the service insertion component format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  spoofguard_ip: :class:`str` or ``None``
        :param spoofguard_ip: This field specified the prefix IP address a traceflow packet
            matched in the whitelist in spoofguard. format: ip-cidr-block
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  spoofguard_mac: :class:`str` or ``None``
        :param spoofguard_mac: The source MAC address of form:
            \"^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$\". For example:
            00:00:00:00:00:00. format: mac-address
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  spoofguard_vlan_id: :class:`long` or ``None``
        :param spoofguard_vlan_id: This field specified the VLAN id a traceflow packet matched in the
            whitelist in spoofguard. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  svc_nh_mac: :class:`str` or ``None``
        :param svc_nh_mac: MAC address of nexthop for service insertion(SI) in service VM(SVM)
            where the traceflow packet was received.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  translated_dst_ip: :class:`str` or ``None``
        :param translated_dst_ip: The translated destination IP address of VNP/NAT format: ip
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  translated_src_ip: :class:`str` or ``None``
        :param translated_src_ip: The translated source IP address of VPN/NAT format: ip
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  vni: :class:`long` or ``None``
        :param vni: VNI for the logical network on which the traceflow packet was
            forwarded. format: int32
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  component_name: :class:`str` or ``None``
        :param component_name: The name of the component that issued the observation.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  component_sub_type: :class:`str` or ``None``
        :param component_sub_type: Possible values are: 
            
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_LR_TIER0`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_LR_TIER1`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_LR_VRF_TIER0`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_LS_TRANSIT`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_SI_CLASSIFIER`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_SI_PROXY`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_VDR`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_ENI`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_AWS_GATEWAY`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_TGW_ROUTE`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_EDGE_UPLINK`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_DELL_GATEWAY`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_UNKNOWN`
            
             The sub type of the component that issued the observation.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  component_type: :class:`str` or ``None``
        :param component_type: Possible values are: 
            
            * :attr:`TraceflowObservation.COMPONENT_TYPE_PHYSICAL`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_LR`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_LS`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_DFW`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_BRIDGE`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_EDGE_TUNNEL`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_EDGE_HOSTSWITCH`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_FW_BRIDGE`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_LOAD_BALANCER`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_NAT`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_IPSEC`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_SERVICE_INSERTION`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_VMC`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_SPOOFGUARD`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_EDGE_FW`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_UNKNOWN`
            
             The type of the component that issued the observation.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONFORWARDED`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONDROPPED`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONDELIVERED`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONRECEIVED`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONFORWARDEDLOGICAL`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONDROPPEDLOGICAL`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONRECEIVEDLOGICAL`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONREPLICATIONLOGICAL`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONRELAYEDLOGICAL`
        :type  sequence_no: :class:`long` or ``None``
        :param sequence_no: the hop count for observations on the transport node that a
            traceflow packet is injected in will be 0. The hop count is
            incremented each time a subsequent transport node receives the
            traceflow packet. The sequence number of 999 indicates that the hop
            count could not be determined for the containing observation.
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  timestamp: :class:`long` or ``None``
        :param timestamp: Timestamp when the observation was created by the transport node
            (milliseconds epoch) format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  timestamp_micro: :class:`long` or ``None``
        :param timestamp_micro: Timestamp when the observation was created by the transport node
            (microseconds epoch) format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  transport_node_id: :class:`str` or ``None``
        :param transport_node_id: id of the transport node that observed a traceflow packet
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  transport_node_name: :class:`str` or ``None``
        :param transport_node_name: name of the transport node that observed a traceflow packet
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  transport_node_type: :class:`str` or ``None``
        :param transport_node_type: Possible values are: 
            
            * :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_ESX`
            * :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_RHELKVM`
            * :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_UBUNTUKVM`
            * :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_EDGE`
            *
              :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_PUBLIC_CLOUD_GATEWAY_NODE`
            * :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_OTHERS`
            * :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_HYPERV`
            
             type of the transport node that observed a traceflow packet
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.acl_rule_id = acl_rule_id
        self.component_id = component_id
        self.dst_component_id = dst_component_id
        self.dst_component_name = dst_component_name
        self.dst_component_type = dst_component_type
        self.lport_id = lport_id
        self.lport_name = lport_name
        self.nat_rule_id = nat_rule_id
        self.resend_type = resend_type
        self.service_index = service_index
        self.service_path_index = service_path_index
        self.service_ttl = service_ttl
        self.spoofguard_ip = spoofguard_ip
        self.spoofguard_mac = spoofguard_mac
        self.spoofguard_vlan_id = spoofguard_vlan_id
        self.svc_nh_mac = svc_nh_mac
        self.translated_dst_ip = translated_dst_ip
        self.translated_src_ip = translated_src_ip
        self.vni = vni
        self.component_name = component_name
        self.component_sub_type = component_sub_type
        self.component_type = component_type
        self._resource_type = resource_type
        self.sequence_no = sequence_no
        self.timestamp = timestamp
        self.timestamp_micro = timestamp_micro
        self.transport_node_id = transport_node_id
        self.transport_node_name = transport_node_name
        self.transport_node_type = transport_node_type
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

TraceflowObservationForwardedLogical._set_binding_type(type.StructType(
    'com.vmware.nsx.model.traceflow_observation_forwarded_logical', {
        'acl_rule_id': type.OptionalType(type.IntegerType()),
        'component_id': type.OptionalType(type.StringType()),
        'dst_component_id': type.OptionalType(type.StringType()),
        'dst_component_name': type.OptionalType(type.StringType()),
        'dst_component_type': type.OptionalType(type.StringType()),
        'lport_id': type.OptionalType(type.StringType()),
        'lport_name': type.OptionalType(type.StringType()),
        'nat_rule_id': type.OptionalType(type.IntegerType()),
        'resend_type': type.OptionalType(type.StringType()),
        'service_index': type.OptionalType(type.IntegerType()),
        'service_path_index': type.OptionalType(type.IntegerType()),
        'service_ttl': type.OptionalType(type.IntegerType()),
        'spoofguard_ip': type.OptionalType(type.StringType()),
        'spoofguard_mac': type.OptionalType(type.StringType()),
        'spoofguard_vlan_id': type.OptionalType(type.IntegerType()),
        'svc_nh_mac': type.OptionalType(type.StringType()),
        'translated_dst_ip': type.OptionalType(type.StringType()),
        'translated_src_ip': type.OptionalType(type.StringType()),
        'vni': type.OptionalType(type.IntegerType()),
        'component_name': type.OptionalType(type.StringType()),
        'component_sub_type': type.OptionalType(type.StringType()),
        'component_type': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'sequence_no': type.OptionalType(type.IntegerType()),
        'timestamp': type.OptionalType(type.IntegerType()),
        'timestamp_micro': type.OptionalType(type.IntegerType()),
        'transport_node_id': type.OptionalType(type.StringType()),
        'transport_node_name': type.OptionalType(type.StringType()),
        'transport_node_type': type.OptionalType(type.StringType()),
    },
    TraceflowObservationForwardedLogical,
    False,
    None))



class TraceflowObservationListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param results: TraceflowObservation list results
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`TraceflowObservation`. When methods return a value of this
            class as a return value, the attribute will contain all the
            attributes defined in :class:`TraceflowObservation`.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


TraceflowObservationListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.traceflow_observation_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'TraceflowObservation')]))),
    },
    TraceflowObservationListResult,
    False,
    None))



class TraceflowObservationReceived(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "TraceflowObservationReceived"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'local_ip_address': 'local_ip_address',
                            'remote_ip_address': 'remote_ip_address',
                            'uplink_name': 'uplink_name',
                            'vtep_label': 'vtep_label',
                            'component_name': 'component_name',
                            'component_sub_type': 'component_sub_type',
                            'component_type': 'component_type',
                            'resource_type': 'resource_type',
                            'sequence_no': 'sequence_no',
                            'timestamp': 'timestamp',
                            'timestamp_micro': 'timestamp_micro',
                            'transport_node_id': 'transport_node_id',
                            'transport_node_name': 'transport_node_name',
                            'transport_node_type': 'transport_node_type',
                            }

    def __init__(self,
                 local_ip_address=None,
                 remote_ip_address=None,
                 uplink_name=None,
                 vtep_label=None,
                 component_name=None,
                 component_sub_type=None,
                 component_type=None,
                 resource_type='TraceflowObservationReceived',
                 sequence_no=None,
                 timestamp=None,
                 timestamp_micro=None,
                 transport_node_id=None,
                 transport_node_name=None,
                 transport_node_type=None,
                ):
        """
        :type  local_ip_address: :class:`str` or ``None``
        :param local_ip_address: IP address of the destination end of the tunnel format: ip
        :type  remote_ip_address: :class:`str` or ``None``
        :param remote_ip_address: IP address of the source end of the tunnel format: ip
        :type  uplink_name: :class:`str` or ``None``
        :param uplink_name: The name of the uplink the traceflow packet is received on
        :type  vtep_label: :class:`long` or ``None``
        :param vtep_label: The virtual tunnel endpoint label format: int64
        :type  component_name: :class:`str` or ``None``
        :param component_name: The name of the component that issued the observation.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  component_sub_type: :class:`str` or ``None``
        :param component_sub_type: Possible values are: 
            
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_LR_TIER0`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_LR_TIER1`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_LR_VRF_TIER0`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_LS_TRANSIT`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_SI_CLASSIFIER`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_SI_PROXY`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_VDR`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_ENI`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_AWS_GATEWAY`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_TGW_ROUTE`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_EDGE_UPLINK`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_DELL_GATEWAY`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_UNKNOWN`
            
             The sub type of the component that issued the observation.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  component_type: :class:`str` or ``None``
        :param component_type: Possible values are: 
            
            * :attr:`TraceflowObservation.COMPONENT_TYPE_PHYSICAL`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_LR`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_LS`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_DFW`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_BRIDGE`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_EDGE_TUNNEL`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_EDGE_HOSTSWITCH`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_FW_BRIDGE`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_LOAD_BALANCER`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_NAT`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_IPSEC`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_SERVICE_INSERTION`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_VMC`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_SPOOFGUARD`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_EDGE_FW`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_UNKNOWN`
            
             The type of the component that issued the observation.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONFORWARDED`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONDROPPED`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONDELIVERED`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONRECEIVED`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONFORWARDEDLOGICAL`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONDROPPEDLOGICAL`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONRECEIVEDLOGICAL`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONREPLICATIONLOGICAL`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONRELAYEDLOGICAL`
        :type  sequence_no: :class:`long` or ``None``
        :param sequence_no: the hop count for observations on the transport node that a
            traceflow packet is injected in will be 0. The hop count is
            incremented each time a subsequent transport node receives the
            traceflow packet. The sequence number of 999 indicates that the hop
            count could not be determined for the containing observation.
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  timestamp: :class:`long` or ``None``
        :param timestamp: Timestamp when the observation was created by the transport node
            (milliseconds epoch) format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  timestamp_micro: :class:`long` or ``None``
        :param timestamp_micro: Timestamp when the observation was created by the transport node
            (microseconds epoch) format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  transport_node_id: :class:`str` or ``None``
        :param transport_node_id: id of the transport node that observed a traceflow packet
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  transport_node_name: :class:`str` or ``None``
        :param transport_node_name: name of the transport node that observed a traceflow packet
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  transport_node_type: :class:`str` or ``None``
        :param transport_node_type: Possible values are: 
            
            * :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_ESX`
            * :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_RHELKVM`
            * :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_UBUNTUKVM`
            * :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_EDGE`
            *
              :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_PUBLIC_CLOUD_GATEWAY_NODE`
            * :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_OTHERS`
            * :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_HYPERV`
            
             type of the transport node that observed a traceflow packet
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.local_ip_address = local_ip_address
        self.remote_ip_address = remote_ip_address
        self.uplink_name = uplink_name
        self.vtep_label = vtep_label
        self.component_name = component_name
        self.component_sub_type = component_sub_type
        self.component_type = component_type
        self._resource_type = resource_type
        self.sequence_no = sequence_no
        self.timestamp = timestamp
        self.timestamp_micro = timestamp_micro
        self.transport_node_id = transport_node_id
        self.transport_node_name = transport_node_name
        self.transport_node_type = transport_node_type
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

TraceflowObservationReceived._set_binding_type(type.StructType(
    'com.vmware.nsx.model.traceflow_observation_received', {
        'local_ip_address': type.OptionalType(type.StringType()),
        'remote_ip_address': type.OptionalType(type.StringType()),
        'uplink_name': type.OptionalType(type.StringType()),
        'vtep_label': type.OptionalType(type.IntegerType()),
        'component_name': type.OptionalType(type.StringType()),
        'component_sub_type': type.OptionalType(type.StringType()),
        'component_type': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'sequence_no': type.OptionalType(type.IntegerType()),
        'timestamp': type.OptionalType(type.IntegerType()),
        'timestamp_micro': type.OptionalType(type.IntegerType()),
        'transport_node_id': type.OptionalType(type.StringType()),
        'transport_node_name': type.OptionalType(type.StringType()),
        'transport_node_type': type.OptionalType(type.StringType()),
    },
    TraceflowObservationReceived,
    False,
    None))



class TraceflowObservationReceivedLogical(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "TraceflowObservationReceivedLogical"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    SRC_COMPONENT_TYPE_PHYSICAL = "PHYSICAL"
    """


    """
    SRC_COMPONENT_TYPE_LR = "LR"
    """


    """
    SRC_COMPONENT_TYPE_LS = "LS"
    """


    """
    SRC_COMPONENT_TYPE_DFW = "DFW"
    """


    """
    SRC_COMPONENT_TYPE_BRIDGE = "BRIDGE"
    """


    """
    SRC_COMPONENT_TYPE_EDGE_TUNNEL = "EDGE_TUNNEL"
    """


    """
    SRC_COMPONENT_TYPE_EDGE_HOSTSWITCH = "EDGE_HOSTSWITCH"
    """


    """
    SRC_COMPONENT_TYPE_FW_BRIDGE = "FW_BRIDGE"
    """


    """
    SRC_COMPONENT_TYPE_LOAD_BALANCER = "LOAD_BALANCER"
    """


    """
    SRC_COMPONENT_TYPE_NAT = "NAT"
    """


    """
    SRC_COMPONENT_TYPE_IPSEC = "IPSEC"
    """


    """
    SRC_COMPONENT_TYPE_SERVICE_INSERTION = "SERVICE_INSERTION"
    """


    """
    SRC_COMPONENT_TYPE_VMC = "VMC"
    """


    """
    SRC_COMPONENT_TYPE_SPOOFGUARD = "SPOOFGUARD"
    """


    """
    SRC_COMPONENT_TYPE_EDGE_FW = "EDGE_FW"
    """


    """
    SRC_COMPONENT_TYPE_UNKNOWN = "UNKNOWN"
    """


    """



    _canonical_to_pep_names = {
                            'component_id': 'component_id',
                            'lport_id': 'lport_id',
                            'lport_name': 'lport_name',
                            'src_component_id': 'src_component_id',
                            'src_component_name': 'src_component_name',
                            'src_component_type': 'src_component_type',
                            'svc_mac': 'svc_mac',
                            'vni': 'vni',
                            'component_name': 'component_name',
                            'component_sub_type': 'component_sub_type',
                            'component_type': 'component_type',
                            'resource_type': 'resource_type',
                            'sequence_no': 'sequence_no',
                            'timestamp': 'timestamp',
                            'timestamp_micro': 'timestamp_micro',
                            'transport_node_id': 'transport_node_id',
                            'transport_node_name': 'transport_node_name',
                            'transport_node_type': 'transport_node_type',
                            }

    def __init__(self,
                 component_id=None,
                 lport_id=None,
                 lport_name=None,
                 src_component_id=None,
                 src_component_name=None,
                 src_component_type=None,
                 svc_mac=None,
                 vni=None,
                 component_name=None,
                 component_sub_type=None,
                 component_type=None,
                 resource_type='TraceflowObservationReceivedLogical',
                 sequence_no=None,
                 timestamp=None,
                 timestamp_micro=None,
                 transport_node_id=None,
                 transport_node_name=None,
                 transport_node_type=None,
                ):
        """
        :type  component_id: :class:`str` or ``None``
        :param component_id: The id of the component that received the traceflow packet.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  lport_id: :class:`str` or ``None``
        :param lport_id: The id of the logical port at which the traceflow packet was
            received
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  lport_name: :class:`str` or ``None``
        :param lport_name: The name of the logical port at which the traceflow packet was
            received
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  src_component_id: :class:`str` or ``None``
        :param src_component_id: The id of the source component from which the traceflow packet was
            received.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  src_component_name: :class:`str` or ``None``
        :param src_component_name: The name of source component from which the traceflow packet was
            received.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  src_component_type: :class:`str` or ``None``
        :param src_component_type: Possible values are: 
            
            *
              :attr:`TraceflowObservationReceivedLogical.SRC_COMPONENT_TYPE_PHYSICAL`
            * :attr:`TraceflowObservationReceivedLogical.SRC_COMPONENT_TYPE_LR`
            * :attr:`TraceflowObservationReceivedLogical.SRC_COMPONENT_TYPE_LS`
            *
              :attr:`TraceflowObservationReceivedLogical.SRC_COMPONENT_TYPE_DFW`
            *
              :attr:`TraceflowObservationReceivedLogical.SRC_COMPONENT_TYPE_BRIDGE`
            *
              :attr:`TraceflowObservationReceivedLogical.SRC_COMPONENT_TYPE_EDGE_TUNNEL`
            *
              :attr:`TraceflowObservationReceivedLogical.SRC_COMPONENT_TYPE_EDGE_HOSTSWITCH`
            *
              :attr:`TraceflowObservationReceivedLogical.SRC_COMPONENT_TYPE_FW_BRIDGE`
            *
              :attr:`TraceflowObservationReceivedLogical.SRC_COMPONENT_TYPE_LOAD_BALANCER`
            *
              :attr:`TraceflowObservationReceivedLogical.SRC_COMPONENT_TYPE_NAT`
            *
              :attr:`TraceflowObservationReceivedLogical.SRC_COMPONENT_TYPE_IPSEC`
            *
              :attr:`TraceflowObservationReceivedLogical.SRC_COMPONENT_TYPE_SERVICE_INSERTION`
            *
              :attr:`TraceflowObservationReceivedLogical.SRC_COMPONENT_TYPE_VMC`
            *
              :attr:`TraceflowObservationReceivedLogical.SRC_COMPONENT_TYPE_SPOOFGUARD`
            *
              :attr:`TraceflowObservationReceivedLogical.SRC_COMPONENT_TYPE_EDGE_FW`
            *
              :attr:`TraceflowObservationReceivedLogical.SRC_COMPONENT_TYPE_UNKNOWN`
            
            The type of the source component from which the traceflow packet
            was received.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  svc_mac: :class:`str` or ``None``
        :param svc_mac: MAC address of SAN volume controller for service insertion(SI) in
            service VM(SVM) where the traceflow packet was received.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  vni: :class:`long` or ``None``
        :param vni: VNI for the logical network on which the traceflow packet was
            received. format: int32
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  component_name: :class:`str` or ``None``
        :param component_name: The name of the component that issued the observation.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  component_sub_type: :class:`str` or ``None``
        :param component_sub_type: Possible values are: 
            
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_LR_TIER0`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_LR_TIER1`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_LR_VRF_TIER0`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_LS_TRANSIT`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_SI_CLASSIFIER`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_SI_PROXY`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_VDR`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_ENI`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_AWS_GATEWAY`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_TGW_ROUTE`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_EDGE_UPLINK`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_DELL_GATEWAY`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_UNKNOWN`
            
             The sub type of the component that issued the observation.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  component_type: :class:`str` or ``None``
        :param component_type: Possible values are: 
            
            * :attr:`TraceflowObservation.COMPONENT_TYPE_PHYSICAL`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_LR`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_LS`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_DFW`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_BRIDGE`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_EDGE_TUNNEL`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_EDGE_HOSTSWITCH`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_FW_BRIDGE`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_LOAD_BALANCER`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_NAT`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_IPSEC`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_SERVICE_INSERTION`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_VMC`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_SPOOFGUARD`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_EDGE_FW`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_UNKNOWN`
            
             The type of the component that issued the observation.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONFORWARDED`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONDROPPED`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONDELIVERED`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONRECEIVED`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONFORWARDEDLOGICAL`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONDROPPEDLOGICAL`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONRECEIVEDLOGICAL`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONREPLICATIONLOGICAL`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONRELAYEDLOGICAL`
        :type  sequence_no: :class:`long` or ``None``
        :param sequence_no: the hop count for observations on the transport node that a
            traceflow packet is injected in will be 0. The hop count is
            incremented each time a subsequent transport node receives the
            traceflow packet. The sequence number of 999 indicates that the hop
            count could not be determined for the containing observation.
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  timestamp: :class:`long` or ``None``
        :param timestamp: Timestamp when the observation was created by the transport node
            (milliseconds epoch) format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  timestamp_micro: :class:`long` or ``None``
        :param timestamp_micro: Timestamp when the observation was created by the transport node
            (microseconds epoch) format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  transport_node_id: :class:`str` or ``None``
        :param transport_node_id: id of the transport node that observed a traceflow packet
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  transport_node_name: :class:`str` or ``None``
        :param transport_node_name: name of the transport node that observed a traceflow packet
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  transport_node_type: :class:`str` or ``None``
        :param transport_node_type: Possible values are: 
            
            * :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_ESX`
            * :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_RHELKVM`
            * :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_UBUNTUKVM`
            * :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_EDGE`
            *
              :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_PUBLIC_CLOUD_GATEWAY_NODE`
            * :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_OTHERS`
            * :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_HYPERV`
            
             type of the transport node that observed a traceflow packet
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.component_id = component_id
        self.lport_id = lport_id
        self.lport_name = lport_name
        self.src_component_id = src_component_id
        self.src_component_name = src_component_name
        self.src_component_type = src_component_type
        self.svc_mac = svc_mac
        self.vni = vni
        self.component_name = component_name
        self.component_sub_type = component_sub_type
        self.component_type = component_type
        self._resource_type = resource_type
        self.sequence_no = sequence_no
        self.timestamp = timestamp
        self.timestamp_micro = timestamp_micro
        self.transport_node_id = transport_node_id
        self.transport_node_name = transport_node_name
        self.transport_node_type = transport_node_type
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

TraceflowObservationReceivedLogical._set_binding_type(type.StructType(
    'com.vmware.nsx.model.traceflow_observation_received_logical', {
        'component_id': type.OptionalType(type.StringType()),
        'lport_id': type.OptionalType(type.StringType()),
        'lport_name': type.OptionalType(type.StringType()),
        'src_component_id': type.OptionalType(type.StringType()),
        'src_component_name': type.OptionalType(type.StringType()),
        'src_component_type': type.OptionalType(type.StringType()),
        'svc_mac': type.OptionalType(type.StringType()),
        'vni': type.OptionalType(type.IntegerType()),
        'component_name': type.OptionalType(type.StringType()),
        'component_sub_type': type.OptionalType(type.StringType()),
        'component_type': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'sequence_no': type.OptionalType(type.IntegerType()),
        'timestamp': type.OptionalType(type.IntegerType()),
        'timestamp_micro': type.OptionalType(type.IntegerType()),
        'transport_node_id': type.OptionalType(type.StringType()),
        'transport_node_name': type.OptionalType(type.StringType()),
        'transport_node_type': type.OptionalType(type.StringType()),
    },
    TraceflowObservationReceivedLogical,
    False,
    None))



class TraceflowObservationRelayedLogical(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "TraceflowObservationRelayedLogical"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    MESSAGE_TYPE_REQUEST = "REQUEST"
    """


    """
    MESSAGE_TYPE_REPLY = "REPLY"
    """


    """



    _canonical_to_pep_names = {
                            'dst_server_address': 'dst_server_address',
                            'logical_comp_uuid': 'logical_comp_uuid',
                            'message_type': 'message_type',
                            'relay_server_address': 'relay_server_address',
                            'component_name': 'component_name',
                            'component_sub_type': 'component_sub_type',
                            'component_type': 'component_type',
                            'resource_type': 'resource_type',
                            'sequence_no': 'sequence_no',
                            'timestamp': 'timestamp',
                            'timestamp_micro': 'timestamp_micro',
                            'transport_node_id': 'transport_node_id',
                            'transport_node_name': 'transport_node_name',
                            'transport_node_type': 'transport_node_type',
                            }

    def __init__(self,
                 dst_server_address=None,
                 logical_comp_uuid=None,
                 message_type=None,
                 relay_server_address=None,
                 component_name=None,
                 component_sub_type=None,
                 component_type=None,
                 resource_type='TraceflowObservationRelayedLogical',
                 sequence_no=None,
                 timestamp=None,
                 timestamp_micro=None,
                 transport_node_id=None,
                 transport_node_name=None,
                 transport_node_type=None,
                ):
        """
        :type  dst_server_address: :class:`str` or ``None``
        :param dst_server_address: This field specified the IP address of the destination which the
            packet will be relayed. format: ip
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  logical_comp_uuid: :class:`str` or ``None``
        :param logical_comp_uuid: This field specified the logical component that relay service
            located.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  message_type: :class:`str` or ``None``
        :param message_type: Possible values are: 
            
            * :attr:`TraceflowObservationRelayedLogical.MESSAGE_TYPE_REQUEST`
            * :attr:`TraceflowObservationRelayedLogical.MESSAGE_TYPE_REPLY`
            
            This field specified the message type of the relay service REQUEST
            - The relay service will relay a request message to the destination
            server REPLY - The relay service will relay a reply message to the
            client
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  relay_server_address: :class:`str` or ``None``
        :param relay_server_address: This field specified the IP address of the relay service. format:
            ip
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  component_name: :class:`str` or ``None``
        :param component_name: The name of the component that issued the observation.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  component_sub_type: :class:`str` or ``None``
        :param component_sub_type: Possible values are: 
            
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_LR_TIER0`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_LR_TIER1`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_LR_VRF_TIER0`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_LS_TRANSIT`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_SI_CLASSIFIER`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_SI_PROXY`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_VDR`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_ENI`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_AWS_GATEWAY`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_TGW_ROUTE`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_EDGE_UPLINK`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_DELL_GATEWAY`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_UNKNOWN`
            
             The sub type of the component that issued the observation.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  component_type: :class:`str` or ``None``
        :param component_type: Possible values are: 
            
            * :attr:`TraceflowObservation.COMPONENT_TYPE_PHYSICAL`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_LR`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_LS`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_DFW`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_BRIDGE`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_EDGE_TUNNEL`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_EDGE_HOSTSWITCH`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_FW_BRIDGE`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_LOAD_BALANCER`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_NAT`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_IPSEC`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_SERVICE_INSERTION`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_VMC`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_SPOOFGUARD`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_EDGE_FW`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_UNKNOWN`
            
             The type of the component that issued the observation.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONFORWARDED`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONDROPPED`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONDELIVERED`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONRECEIVED`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONFORWARDEDLOGICAL`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONDROPPEDLOGICAL`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONRECEIVEDLOGICAL`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONREPLICATIONLOGICAL`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONRELAYEDLOGICAL`
        :type  sequence_no: :class:`long` or ``None``
        :param sequence_no: the hop count for observations on the transport node that a
            traceflow packet is injected in will be 0. The hop count is
            incremented each time a subsequent transport node receives the
            traceflow packet. The sequence number of 999 indicates that the hop
            count could not be determined for the containing observation.
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  timestamp: :class:`long` or ``None``
        :param timestamp: Timestamp when the observation was created by the transport node
            (milliseconds epoch) format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  timestamp_micro: :class:`long` or ``None``
        :param timestamp_micro: Timestamp when the observation was created by the transport node
            (microseconds epoch) format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  transport_node_id: :class:`str` or ``None``
        :param transport_node_id: id of the transport node that observed a traceflow packet
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  transport_node_name: :class:`str` or ``None``
        :param transport_node_name: name of the transport node that observed a traceflow packet
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  transport_node_type: :class:`str` or ``None``
        :param transport_node_type: Possible values are: 
            
            * :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_ESX`
            * :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_RHELKVM`
            * :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_UBUNTUKVM`
            * :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_EDGE`
            *
              :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_PUBLIC_CLOUD_GATEWAY_NODE`
            * :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_OTHERS`
            * :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_HYPERV`
            
             type of the transport node that observed a traceflow packet
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.dst_server_address = dst_server_address
        self.logical_comp_uuid = logical_comp_uuid
        self.message_type = message_type
        self.relay_server_address = relay_server_address
        self.component_name = component_name
        self.component_sub_type = component_sub_type
        self.component_type = component_type
        self._resource_type = resource_type
        self.sequence_no = sequence_no
        self.timestamp = timestamp
        self.timestamp_micro = timestamp_micro
        self.transport_node_id = transport_node_id
        self.transport_node_name = transport_node_name
        self.transport_node_type = transport_node_type
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

TraceflowObservationRelayedLogical._set_binding_type(type.StructType(
    'com.vmware.nsx.model.traceflow_observation_relayed_logical', {
        'dst_server_address': type.OptionalType(type.StringType()),
        'logical_comp_uuid': type.OptionalType(type.StringType()),
        'message_type': type.OptionalType(type.StringType()),
        'relay_server_address': type.OptionalType(type.StringType()),
        'component_name': type.OptionalType(type.StringType()),
        'component_sub_type': type.OptionalType(type.StringType()),
        'component_type': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'sequence_no': type.OptionalType(type.IntegerType()),
        'timestamp': type.OptionalType(type.IntegerType()),
        'timestamp_micro': type.OptionalType(type.IntegerType()),
        'transport_node_id': type.OptionalType(type.StringType()),
        'transport_node_name': type.OptionalType(type.StringType()),
        'transport_node_type': type.OptionalType(type.StringType()),
    },
    TraceflowObservationRelayedLogical,
    False,
    None))



class TraceflowObservationReplicationLogical(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "TraceflowObservationReplicationLogical"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    REPLICATION_TYPE_TX_VTEP = "TX_VTEP"
    """


    """
    REPLICATION_TYPE_TX_MTEP = "TX_MTEP"
    """


    """
    REPLICATION_TYPE_RX = "RX"
    """


    """



    _canonical_to_pep_names = {
                            'local_ip_address': 'local_ip_address',
                            'replication_type': 'replication_type',
                            'uplink_name': 'uplink_name',
                            'vtep_label': 'vtep_label',
                            'component_name': 'component_name',
                            'component_sub_type': 'component_sub_type',
                            'component_type': 'component_type',
                            'resource_type': 'resource_type',
                            'sequence_no': 'sequence_no',
                            'timestamp': 'timestamp',
                            'timestamp_micro': 'timestamp_micro',
                            'transport_node_id': 'transport_node_id',
                            'transport_node_name': 'transport_node_name',
                            'transport_node_type': 'transport_node_type',
                            }

    def __init__(self,
                 local_ip_address=None,
                 replication_type=None,
                 uplink_name=None,
                 vtep_label=None,
                 component_name=None,
                 component_sub_type=None,
                 component_type=None,
                 resource_type='TraceflowObservationReplicationLogical',
                 sequence_no=None,
                 timestamp=None,
                 timestamp_micro=None,
                 transport_node_id=None,
                 transport_node_name=None,
                 transport_node_type=None,
                ):
        """
        :type  local_ip_address: :class:`str` or ``None``
        :param local_ip_address: Local IP address of the component that replicates the packet.
            format: ip
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  replication_type: :class:`str` or ``None``
        :param replication_type: Possible values are: 
            
            *
              :attr:`TraceflowObservationReplicationLogical.REPLICATION_TYPE_TX_VTEP`
            *
              :attr:`TraceflowObservationReplicationLogical.REPLICATION_TYPE_TX_MTEP`
            *
              :attr:`TraceflowObservationReplicationLogical.REPLICATION_TYPE_RX`
            
            This field specifies the type of replication message TX_VTEP -
            Transmit replication to all VTEPs TX_MTEP - Transmit replication to
            all MTEPs RX - Receive replication
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  uplink_name: :class:`str` or ``None``
        :param uplink_name: The name of uplink
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  vtep_label: :class:`long` or ``None``
        :param vtep_label: The label of VTEP format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  component_name: :class:`str` or ``None``
        :param component_name: The name of the component that issued the observation.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  component_sub_type: :class:`str` or ``None``
        :param component_sub_type: Possible values are: 
            
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_LR_TIER0`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_LR_TIER1`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_LR_VRF_TIER0`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_LS_TRANSIT`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_SI_CLASSIFIER`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_SI_PROXY`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_VDR`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_ENI`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_AWS_GATEWAY`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_TGW_ROUTE`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_EDGE_UPLINK`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_DELL_GATEWAY`
            * :attr:`TraceflowObservation.COMPONENT_SUB_TYPE_UNKNOWN`
            
             The sub type of the component that issued the observation.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  component_type: :class:`str` or ``None``
        :param component_type: Possible values are: 
            
            * :attr:`TraceflowObservation.COMPONENT_TYPE_PHYSICAL`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_LR`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_LS`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_DFW`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_BRIDGE`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_EDGE_TUNNEL`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_EDGE_HOSTSWITCH`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_FW_BRIDGE`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_LOAD_BALANCER`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_NAT`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_IPSEC`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_SERVICE_INSERTION`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_VMC`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_SPOOFGUARD`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_EDGE_FW`
            * :attr:`TraceflowObservation.COMPONENT_TYPE_UNKNOWN`
            
             The type of the component that issued the observation.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONFORWARDED`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONDROPPED`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONDELIVERED`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONRECEIVED`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONFORWARDEDLOGICAL`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONDROPPEDLOGICAL`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONRECEIVEDLOGICAL`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONREPLICATIONLOGICAL`
            *
              :attr:`TraceflowObservation.RESOURCE_TYPE_TRACEFLOWOBSERVATIONRELAYEDLOGICAL`
        :type  sequence_no: :class:`long` or ``None``
        :param sequence_no: the hop count for observations on the transport node that a
            traceflow packet is injected in will be 0. The hop count is
            incremented each time a subsequent transport node receives the
            traceflow packet. The sequence number of 999 indicates that the hop
            count could not be determined for the containing observation.
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  timestamp: :class:`long` or ``None``
        :param timestamp: Timestamp when the observation was created by the transport node
            (milliseconds epoch) format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  timestamp_micro: :class:`long` or ``None``
        :param timestamp_micro: Timestamp when the observation was created by the transport node
            (microseconds epoch) format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  transport_node_id: :class:`str` or ``None``
        :param transport_node_id: id of the transport node that observed a traceflow packet
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  transport_node_name: :class:`str` or ``None``
        :param transport_node_name: name of the transport node that observed a traceflow packet
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  transport_node_type: :class:`str` or ``None``
        :param transport_node_type: Possible values are: 
            
            * :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_ESX`
            * :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_RHELKVM`
            * :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_UBUNTUKVM`
            * :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_EDGE`
            *
              :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_PUBLIC_CLOUD_GATEWAY_NODE`
            * :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_OTHERS`
            * :attr:`TraceflowObservation.TRANSPORT_NODE_TYPE_HYPERV`
            
             type of the transport node that observed a traceflow packet
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.local_ip_address = local_ip_address
        self.replication_type = replication_type
        self.uplink_name = uplink_name
        self.vtep_label = vtep_label
        self.component_name = component_name
        self.component_sub_type = component_sub_type
        self.component_type = component_type
        self._resource_type = resource_type
        self.sequence_no = sequence_no
        self.timestamp = timestamp
        self.timestamp_micro = timestamp_micro
        self.transport_node_id = transport_node_id
        self.transport_node_name = transport_node_name
        self.transport_node_type = transport_node_type
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

TraceflowObservationReplicationLogical._set_binding_type(type.StructType(
    'com.vmware.nsx.model.traceflow_observation_replication_logical', {
        'local_ip_address': type.OptionalType(type.StringType()),
        'replication_type': type.OptionalType(type.StringType()),
        'uplink_name': type.OptionalType(type.StringType()),
        'vtep_label': type.OptionalType(type.IntegerType()),
        'component_name': type.OptionalType(type.StringType()),
        'component_sub_type': type.OptionalType(type.StringType()),
        'component_type': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'sequence_no': type.OptionalType(type.IntegerType()),
        'timestamp': type.OptionalType(type.IntegerType()),
        'timestamp_micro': type.OptionalType(type.IntegerType()),
        'transport_node_id': type.OptionalType(type.StringType()),
        'transport_node_name': type.OptionalType(type.StringType()),
        'transport_node_type': type.OptionalType(type.StringType()),
    },
    TraceflowObservationReplicationLogical,
    False,
    None))



class TraceflowRequest(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'lport_id': 'lport_id',
                            'packet': 'packet',
                            'timeout': 'timeout',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 lport_id=None,
                 packet=None,
                 timeout=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  lport_id: :class:`str` or ``None``
        :param lport_id: id of the source logical port to inject the traceflow packet into
        :type  packet: :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param packet: Packet configuration
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`PacketData`. When methods return a value of this class as a
            return value, the attribute will contain all the attributes defined
            in :class:`PacketData`.
        :type  timeout: :class:`long` or ``None``
        :param timeout: Maximum time (in ms) the management plane will wait for observation
            result list to be sent by controller plane. format: int64
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.lport_id = lport_id
        self.packet = packet
        self.timeout = timeout
        VapiStruct.__init__(self)


TraceflowRequest._set_binding_type(type.StructType(
    'com.vmware.nsx.model.traceflow_request', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'lport_id': type.OptionalType(type.StringType()),
        'packet': type.OptionalType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'PacketData')])),
        'timeout': type.OptionalType(type.IntegerType()),
    },
    TraceflowRequest,
    False,
    None))



class TransportNode(VapiStruct):
    """
    Transport Node

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    MAINTENANCE_MODE_ENABLED = "ENABLED"
    """


    """
    MAINTENANCE_MODE_FORCE_ENABLED = "FORCE_ENABLED"
    """


    """
    MAINTENANCE_MODE_DISABLED = "DISABLED"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'failure_domain_id': 'failure_domain_id',
                            'host_switch_spec': 'host_switch_spec',
                            'is_overridden': 'is_overridden',
                            'maintenance_mode': 'maintenance_mode',
                            'node_deployment_info': 'node_deployment_info',
                            'node_id': 'node_id',
                            'remote_tunnel_endpoint': 'remote_tunnel_endpoint',
                            'transport_zone_endpoints': 'transport_zone_endpoints',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 failure_domain_id=None,
                 host_switch_spec=None,
                 is_overridden=None,
                 maintenance_mode=None,
                 node_deployment_info=None,
                 node_id=None,
                 remote_tunnel_endpoint=None,
                 transport_zone_endpoints=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  failure_domain_id: :class:`str` or ``None``
        :param failure_domain_id: Set failure domain of edge transport node which will help in auto
            placement of TIER1 logical routers, DHCP Servers and MDProxies, if
            failure domain based allocation is enabled in edge cluster API. It
            is only supported for edge transport node and not for host
            transport node. In case failure domain is not set by user
            explicitly, it will be always assigned with default system created
            failure domain.
        :type  host_switch_spec: :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param host_switch_spec: This property is used to either create standard host switches or to
            inform NSX about preconfigured host switches that already exist on
            the transport node. Pass an array of either StandardHostSwitchSpec
            objects or PreconfiguredHostSwitchSpec objects. It is an error to
            pass an array containing different types of HostSwitchSpec objects.
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`HostSwitchSpec`. When methods return a value of this class
            as a return value, the attribute will contain all the attributes
            defined in :class:`HostSwitchSpec`.
        :type  is_overridden: :class:`bool` or ``None``
        :param is_overridden: This flag is relevant to only those hosts which are part of a
            compute collection which has transport node profile (TNP) applied
            on it. If you change the transport node configuration and it is
            different than cluster level TNP then this flag will be set to true
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  maintenance_mode: :class:`str` or ``None``
        :param maintenance_mode: Possible values are: 
            
            * :attr:`TransportNode.MAINTENANCE_MODE_ENABLED`
            * :attr:`TransportNode.MAINTENANCE_MODE_FORCE_ENABLED`
            * :attr:`TransportNode.MAINTENANCE_MODE_DISABLED`
            
            The property is read-only, used for querying result. User could
            update transport node maintenance mode by
            UpdateTransportNodeMaintenanceMode call.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  node_deployment_info: :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param node_deployment_info: 
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in :class:`Node`.
            When methods return a value of this class as a return value, the
            attribute will contain all the attributes defined in :class:`Node`.
        :type  node_id: :class:`str` or ``None``
        :param node_id: Unique Id of the fabric node
        :type  remote_tunnel_endpoint: :class:`TransportNodeRemoteTunnelEndpointConfig` or ``None``
        :param remote_tunnel_endpoint: This should be configured only on a single host switch. It is only
            supported for edge transport nodes and not for host transport
            nodes. This configuration will be used by overlay traffic that is
            meant to be sent between NSX intersite domains.
        :type  transport_zone_endpoints: :class:`list` of :class:`TransportZoneEndPoint` or ``None``
        :param transport_zone_endpoints: This is deprecated. TransportZoneEndPoints should be specified per
            host switch at StandardHostSwitch through Transport Node or
            Transport Node Profile configuration. This will ONLY include the
            TransportZoneEndpoints that were were specified here during the
            TransportNode configuration. If TransportZoneEndpoints are
            specified directly in {$ref: StandardHostSwitch}, such
            TransportZoneEndpoints will not be populated here.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.failure_domain_id = failure_domain_id
        self.host_switch_spec = host_switch_spec
        self.is_overridden = is_overridden
        self.maintenance_mode = maintenance_mode
        self.node_deployment_info = node_deployment_info
        self.node_id = node_id
        self.remote_tunnel_endpoint = remote_tunnel_endpoint
        self.transport_zone_endpoints = transport_zone_endpoints
        VapiStruct.__init__(self)


TransportNode._set_binding_type(type.StructType(
    'com.vmware.nsx.model.transport_node', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'failure_domain_id': type.OptionalType(type.StringType()),
        'host_switch_spec': type.OptionalType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'HostSwitchSpec')])),
        'is_overridden': type.OptionalType(type.BooleanType()),
        'maintenance_mode': type.OptionalType(type.StringType()),
        'node_deployment_info': type.OptionalType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'Node')])),
        'node_id': type.OptionalType(type.StringType()),
        'remote_tunnel_endpoint': type.OptionalType(type.ReferenceType(__name__, 'TransportNodeRemoteTunnelEndpointConfig')),
        'transport_zone_endpoints': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'TransportZoneEndPoint'))),
    },
    TransportNode,
    False,
    None))



class TransportNodeCollection(VapiStruct):
    """
    Entity to indicate relation between Compute collection and Transport node
    template

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'compute_collection_id': 'compute_collection_id',
                            'transport_node_profile_id': 'transport_node_profile_id',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 compute_collection_id=None,
                 transport_node_profile_id=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  compute_collection_id: :class:`str` or ``None``
        :param compute_collection_id: Compute collection id
        :type  transport_node_profile_id: :class:`str` or ``None``
        :param transport_node_profile_id: Transport Node Profile ID
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.compute_collection_id = compute_collection_id
        self.transport_node_profile_id = transport_node_profile_id
        VapiStruct.__init__(self)


TransportNodeCollection._set_binding_type(type.StructType(
    'com.vmware.nsx.model.transport_node_collection', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'compute_collection_id': type.OptionalType(type.StringType()),
        'transport_node_profile_id': type.OptionalType(type.StringType()),
    },
    TransportNodeCollection,
    False,
    None))



class TransportNodeCollectionListResult(VapiStruct):
    """
    Transport Node collections list result

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`TransportNodeCollection` or ``None``
        :param results: Transport Node collection results
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


TransportNodeCollectionListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.transport_node_collection_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'TransportNodeCollection'))),
    },
    TransportNodeCollectionListResult,
    False,
    None))



class TransportNodeCollectionState(VapiStruct):
    """
    Realization state of attaching or detaching Transport node profile on
    compute collection.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATE_FAILED_TO_CREATE = "FAILED_TO_CREATE"
    """


    """
    STATE_FAILED_TO_REALIZE = "FAILED_TO_REALIZE"
    """


    """
    STATE_IN_PROGRESS = "IN_PROGRESS"
    """


    """
    STATE_PROFILE_MISMATCH = "PROFILE_MISMATCH"
    """


    """
    STATE_SUCCESS = "SUCCESS"
    """


    """



    _canonical_to_pep_names = {
                            'aggregate_progress_percentage': 'aggregate_progress_percentage',
                            'state': 'state',
                            'validation_errors': 'validation_errors',
                            }

    def __init__(self,
                 aggregate_progress_percentage=None,
                 state=None,
                 validation_errors=None,
                ):
        """
        :type  aggregate_progress_percentage: :class:`long` or ``None``
        :param aggregate_progress_percentage: Average of all transport node deployment progress in a cluster.
            Applicable only if transport node profile is applied on a cluster.
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  state: :class:`str` or ``None``
        :param state: Possible values are: 
            
            * :attr:`TransportNodeCollectionState.STATE_FAILED_TO_CREATE`
            * :attr:`TransportNodeCollectionState.STATE_FAILED_TO_REALIZE`
            * :attr:`TransportNodeCollectionState.STATE_IN_PROGRESS`
            * :attr:`TransportNodeCollectionState.STATE_PROFILE_MISMATCH`
            * :attr:`TransportNodeCollectionState.STATE_SUCCESS`
            
            If the host preparation or transport node creation is going on for
            any host then state will be \"IN_PROGRESS\". If setting desired
            state of the transport node failed for any of the host then state
            will be \"FAILED_TO_CREATE\" If realization of transport node
            failed for any of the host then state will be \"FAILED_TO_REALIZE\"
            If Transport node is successfully created for all of the hosts in
            compute collection then state will be \"SUCCESS\" You can override
            the configuration for one or more hosts in the compute collection
            by update TN(transport node) request on individual TN. If TN is
            successfully created for all hosts in compute collection and one or
            more hosts have overridden configuration then transport node
            collection state will be \"PROFILE_MISMATCH\".
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  validation_errors: :class:`list` of :class:`ValidationError` or ``None``
        :param validation_errors: Transport node profile(TNP) will not be applied to a discovered
            node(DN) if some validations are not passed. In this case transport
            node is not created or existing transport node is not updated with
            TNP configurations.
        """
        self.aggregate_progress_percentage = aggregate_progress_percentage
        self.state = state
        self.validation_errors = validation_errors
        VapiStruct.__init__(self)


TransportNodeCollectionState._set_binding_type(type.StructType(
    'com.vmware.nsx.model.transport_node_collection_state', {
        'aggregate_progress_percentage': type.OptionalType(type.IntegerType()),
        'state': type.OptionalType(type.StringType()),
        'validation_errors': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ValidationError'))),
    },
    TransportNodeCollectionState,
    False,
    None))



class TransportNodeDeploymentProgressState(VapiStruct):
    """
    Deployment progress state of transport node. Object has current deployment
    step title and progress in percentage.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'current_step_title': 'current_step_title',
                            'progress': 'progress',
                            }

    def __init__(self,
                 current_step_title=None,
                 progress=None,
                ):
        """
        :type  current_step_title: :class:`str` or ``None``
        :param current_step_title: Deployment step title
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  progress: :class:`long` or ``None``
        :param progress: Percentage of deployment completed format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.current_step_title = current_step_title
        self.progress = progress
        VapiStruct.__init__(self)


TransportNodeDeploymentProgressState._set_binding_type(type.StructType(
    'com.vmware.nsx.model.transport_node_deployment_progress_state', {
        'current_step_title': type.OptionalType(type.StringType()),
        'progress': type.OptionalType(type.IntegerType()),
    },
    TransportNodeDeploymentProgressState,
    False,
    None))



class TransportNodeListResult(VapiStruct):
    """
    Transport Node queries result

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`TransportNode` or ``None``
        :param results: TransportNode Results
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


TransportNodeListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.transport_node_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'TransportNode'))),
    },
    TransportNodeListResult,
    False,
    None))



class TransportNodeMemberInfo(VapiStruct):
    """
    Information about participating transport nodes

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'compute_collection_id': 'compute_collection_id',
                            'host_switches': 'host_switches',
                            'transport_node_display_name': 'transport_node_display_name',
                            'transport_node_id': 'transport_node_id',
                            }

    def __init__(self,
                 compute_collection_id=None,
                 host_switches=None,
                 transport_node_display_name=None,
                 transport_node_id=None,
                ):
        """
        :type  compute_collection_id: :class:`str` or ``None``
        :param compute_collection_id: Id of the compute collection to which this transport node belongs.
            Empty if this is standalone transport node or non ESX type node.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  host_switches: :class:`list` of :class:`HostSwitchInfo` or ``None``
        :param host_switches: List of host switches using the transport zone
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  transport_node_display_name: :class:`str` or ``None``
        :param transport_node_display_name: Display name of the transport node which has one or more host
            switches which belong to associated transport zone.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  transport_node_id: :class:`str` or ``None``
        :param transport_node_id: Id of the transport node which has one or more host switches which
            belong to associated transport zone.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.compute_collection_id = compute_collection_id
        self.host_switches = host_switches
        self.transport_node_display_name = transport_node_display_name
        self.transport_node_id = transport_node_id
        VapiStruct.__init__(self)


TransportNodeMemberInfo._set_binding_type(type.StructType(
    'com.vmware.nsx.model.transport_node_member_info', {
        'compute_collection_id': type.OptionalType(type.StringType()),
        'host_switches': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'HostSwitchInfo'))),
        'transport_node_display_name': type.OptionalType(type.StringType()),
        'transport_node_id': type.OptionalType(type.StringType()),
    },
    TransportNodeMemberInfo,
    False,
    None))



class TransportNodeProfile(VapiStruct):
    """
    Transport Node Profile

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'host_switch_spec': 'host_switch_spec',
                            'transport_zone_endpoints': 'transport_zone_endpoints',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 host_switch_spec=None,
                 transport_zone_endpoints=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  host_switch_spec: :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param host_switch_spec: The HostSwitchSpec is the base class for standard and preconfigured
            host switch specifications. Only standard host switches are
            supported in the transport node profile.
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`HostSwitchSpec`. When methods return a value of this class
            as a return value, the attribute will contain all the attributes
            defined in :class:`HostSwitchSpec`.
        :type  transport_zone_endpoints: :class:`list` of :class:`TransportZoneEndPoint` or ``None``
        :param transport_zone_endpoints: This is deprecated. TransportZoneEndPoints should be specified per
            host switch at StandardHostSwitch through Transport Node or
            Transport Node Profile configuration. This will ONLY include the
            TransportZoneEndpoints that were were specified here during the
            TransportNode configuration. If TransportZoneEndpoints are
            specified directly in {$ref: StandardHostSwitch}, such
            TransportZoneEndpoints will not be populated here.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.host_switch_spec = host_switch_spec
        self.transport_zone_endpoints = transport_zone_endpoints
        VapiStruct.__init__(self)


TransportNodeProfile._set_binding_type(type.StructType(
    'com.vmware.nsx.model.transport_node_profile', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'host_switch_spec': type.OptionalType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'HostSwitchSpec')])),
        'transport_zone_endpoints': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'TransportZoneEndPoint'))),
    },
    TransportNodeProfile,
    False,
    None))



class TransportNodeProfileListResult(VapiStruct):
    """
    Transport Node Profile queries result

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`TransportNodeProfile` or ``None``
        :param results: TransportNodeProfile Results
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


TransportNodeProfileListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.transport_node_profile_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'TransportNodeProfile'))),
    },
    TransportNodeProfileListResult,
    False,
    None))



class TransportNodeRemoteTunnelEndpointConfig(VapiStruct):
    """
    Remote tunnel endpoint configuration

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'host_switch_name': 'host_switch_name',
                            'ip_assignment_spec': 'ip_assignment_spec',
                            'named_teaming_policy': 'named_teaming_policy',
                            'rtep_vlan': 'rtep_vlan',
                            }

    def __init__(self,
                 host_switch_name=None,
                 ip_assignment_spec=None,
                 named_teaming_policy=None,
                 rtep_vlan=None,
                ):
        """
        :type  host_switch_name: :class:`str` or ``None``
        :param host_switch_name: The host switch name should reference an existing host switch
            specified in the transport node configuration. The name will be
            used to identify the host switch responsible for processing remote
            tunnel endpoint traffic.
        :type  ip_assignment_spec: :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param ip_assignment_spec: IPs can come from either a static IP pool or an explicitly
            specified IP list. Therefore, specifying any other IP assignment
            type will result in error. In case a list of IPs is specified, the
            number of IPs provided should be sufficient as per the teaming
            policy associated with the host switch uplink profile used by the
            remote tunnel endpoint.
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`IpAssignmentSpec`. When methods return a value of this
            class as a return value, the attribute will contain all the
            attributes defined in :class:`IpAssignmentSpec`.
        :type  named_teaming_policy: :class:`str` or ``None``
        :param named_teaming_policy: Specifying this field will override the default teaming policy of
            the host switch and will be used by remote tunnel endpoint traffic.
        :type  rtep_vlan: :class:`long` or ``None``
        :param rtep_vlan: The transport VLAN id used for tagging intersite overlay traffic
            between remote tunnel endpoints. format: int64
        """
        self.host_switch_name = host_switch_name
        self.ip_assignment_spec = ip_assignment_spec
        self.named_teaming_policy = named_teaming_policy
        self.rtep_vlan = rtep_vlan
        VapiStruct.__init__(self)


TransportNodeRemoteTunnelEndpointConfig._set_binding_type(type.StructType(
    'com.vmware.nsx.model.transport_node_remote_tunnel_endpoint_config', {
        'host_switch_name': type.OptionalType(type.StringType()),
        'ip_assignment_spec': type.OptionalType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'IpAssignmentSpec')])),
        'named_teaming_policy': type.OptionalType(type.StringType()),
        'rtep_vlan': type.OptionalType(type.IntegerType()),
    },
    TransportNodeRemoteTunnelEndpointConfig,
    False,
    None))



class TransportNodeState(VapiStruct):
    """
    Transport Node State

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATE_PENDING = "pending"
    """


    """
    STATE_IN_PROGRESS = "in_progress"
    """


    """
    STATE_SUCCESS = "success"
    """


    """
    STATE_FAILED = "failed"
    """


    """
    STATE_PARTIAL_SUCCESS = "partial_success"
    """


    """
    STATE_ORPHANED = "orphaned"
    """


    """
    STATE_UNKNOWN = "unknown"
    """


    """
    STATE_ERROR = "error"
    """


    """
    STATE_IN_SYNC = "in_sync"
    """


    """
    STATE_NOT_AVAILABLE = "NOT_AVAILABLE"
    """


    """
    STATE_VM_DEPLOYMENT_QUEUED = "VM_DEPLOYMENT_QUEUED"
    """


    """
    STATE_VM_DEPLOYMENT_IN_PROGRESS = "VM_DEPLOYMENT_IN_PROGRESS"
    """


    """
    STATE_VM_DEPLOYMENT_FAILED = "VM_DEPLOYMENT_FAILED"
    """


    """
    STATE_VM_POWER_ON_IN_PROGRESS = "VM_POWER_ON_IN_PROGRESS"
    """


    """
    STATE_VM_POWER_ON_FAILED = "VM_POWER_ON_FAILED"
    """


    """
    STATE_REGISTRATION_PENDING = "REGISTRATION_PENDING"
    """


    """
    STATE_NODE_NOT_READY = "NODE_NOT_READY"
    """


    """
    STATE_NODE_READY = "NODE_READY"
    """


    """
    STATE_VM_POWER_OFF_IN_PROGRESS = "VM_POWER_OFF_IN_PROGRESS"
    """


    """
    STATE_VM_POWER_OFF_FAILED = "VM_POWER_OFF_FAILED"
    """


    """
    STATE_VM_UNDEPLOY_IN_PROGRESS = "VM_UNDEPLOY_IN_PROGRESS"
    """


    """
    STATE_VM_UNDEPLOY_FAILED = "VM_UNDEPLOY_FAILED"
    """


    """
    STATE_VM_UNDEPLOY_SUCCESSFUL = "VM_UNDEPLOY_SUCCESSFUL"
    """


    """
    STATE_EDGE_CONFIG_ERROR = "EDGE_CONFIG_ERROR"
    """


    """
    STATE_VM_DEPLOYMENT_RESTARTED = "VM_DEPLOYMENT_RESTARTED"
    """


    """
    STATE_REGISTRATION_FAILED = "REGISTRATION_FAILED"
    """


    """
    STATE_TRANSPORT_NODE_SYNC_PENDING = "TRANSPORT_NODE_SYNC_PENDING"
    """


    """
    STATE_TRANSPORT_NODE_CONFIGURATION_MISSING = "TRANSPORT_NODE_CONFIGURATION_MISSING"
    """


    """
    STATE_EDGE_HARDWARE_NOT_SUPPORTED = "EDGE_HARDWARE_NOT_SUPPORTED"
    """


    """
    STATE_MULTIPLE_OVERLAY_TZS_NOT_SUPPORTED = "MULTIPLE_OVERLAY_TZS_NOT_SUPPORTED"
    """


    """
    STATE_TN_OVERLAY_TZ_IN_USE_BY_EDGE_CLUSTER = "TN_OVERLAY_TZ_IN_USE_BY_EDGE_CLUSTER"
    """


    """
    STATE_TZ_ENDPOINTS_NOT_SPECIFIED = "TZ_ENDPOINTS_NOT_SPECIFIED"
    """


    """
    STATE_NO_PNIC_PREPARED_IN_EDGE = "NO_PNIC_PREPARED_IN_EDGE"
    """


    """
    STATE_APPLIANCE_INTERNAL_ERROR = "APPLIANCE_INTERNAL_ERROR"
    """


    """
    STATE_VTEP_DHCP_NOT_SUPPORTED = "VTEP_DHCP_NOT_SUPPORTED"
    """


    """
    STATE_UNSUPPORTED_HOST_SWITCH_PROFILE = "UNSUPPORTED_HOST_SWITCH_PROFILE"
    """


    """
    STATE_UPLINK_HOST_SWITCH_PROFILE_NOT_SPECIFIED = "UPLINK_HOST_SWITCH_PROFILE_NOT_SPECIFIED"
    """


    """
    STATE_HOSTSWITCH_PROFILE_NOT_FOUND = "HOSTSWITCH_PROFILE_NOT_FOUND"
    """


    """
    STATE_LLDP_SEND_ENABLED_NOT_SUPPORTED = "LLDP_SEND_ENABLED_NOT_SUPPORTED"
    """


    """
    STATE_UNSUPPORTED_NAMED_TEAMING_POLICY = "UNSUPPORTED_NAMED_TEAMING_POLICY"
    """


    """
    STATE_LBSRCID_NOT_SUPPORTED_FOR_EDGE_VM = "LBSRCID_NOT_SUPPORTED_FOR_EDGE_VM"
    """


    """
    STATE_LACP_NOT_SUPPORTED_FOR_EDGE_VM = "LACP_NOT_SUPPORTED_FOR_EDGE_VM"
    """


    """
    STATE_STANDBY_UPLINKS_NOT_SUPPORTED_FOR_EDGE_VM = "STANDBY_UPLINKS_NOT_SUPPORTED_FOR_EDGE_VM"
    """


    """
    STATE_MULTIPLE_ACTIVE_UPLINKS_NOT_SUPPORTED_FOR_EDGE = "MULTIPLE_ACTIVE_UPLINKS_NOT_SUPPORTED_FOR_EDGE"
    """


    """
    STATE_UNSUPPORTED_LACP_LB_ALGO_FOR_NODE = "UNSUPPORTED_LACP_LB_ALGO_FOR_NODE"
    """


    """
    STATE_EDGE_NODE_VERSION_NOT_SUPPORTED = "EDGE_NODE_VERSION_NOT_SUPPORTED"
    """


    """
    STATE_NO_PNIC_SPECIFIED_IN_TN = "NO_PNIC_SPECIFIED_IN_TN"
    """


    """
    STATE_INVALID_PNIC_DEVICE_NAME = "INVALID_PNIC_DEVICE_NAME"
    """


    """
    STATE_TRANSPORT_NODE_READY = "TRANSPORT_NODE_READY"
    """


    """
    STATE_VM_NETWORK_EDIT_PENDING = "VM_NETWORK_EDIT_PENDING"
    """


    """
    STATE_UNSUPPORTED_DEFAULT_TEAMING_POLICY = "UNSUPPORTED_DEFAULT_TEAMING_POLICY"
    """


    """
    STATE_MPA_DISCONNECTED = "MPA_DISCONNECTED"
    """


    """
    STATE_VM_RENAME_PENDING = "VM_RENAME_PENDING"
    """


    """
    STATE_VM_CONFIG_EDIT_PENDING = "VM_CONFIG_EDIT_PENDING"
    """


    """
    STATE_VM_NETWORK_EDIT_FAILED = "VM_NETWORK_EDIT_FAILED"
    """


    """
    STATE_VM_RENAME_FAILED = "VM_RENAME_FAILED"
    """


    """
    STATE_VM_CONFIG_EDIT_FAILED = "VM_CONFIG_EDIT_FAILED"
    """


    """
    STATE_VM_CONFIG_DISCREPANCY = "VM_CONFIG_DISCREPANCY"
    """


    """
    STATE_VM_NODE_REFRESH_FAILED = "VM_NODE_REFRESH_FAILED"
    """


    """
    STATE_VM_PLACEMENT_REFRESH_FAILED = "VM_PLACEMENT_REFRESH_FAILED"
    """


    """
    STATE_REGISTRATION_TIMEDOUT = "REGISTRATION_TIMEDOUT"
    """


    """
    MAINTENANCE_MODE_STATE_ENTERING = "ENTERING"
    """


    """
    MAINTENANCE_MODE_STATE_ENABLED = "ENABLED"
    """


    """
    MAINTENANCE_MODE_STATE_EXITING = "EXITING"
    """


    """
    MAINTENANCE_MODE_STATE_DISABLED = "DISABLED"
    """


    """



    _canonical_to_pep_names = {
                            'details': 'details',
                            'failure_code': 'failure_code',
                            'failure_message': 'failure_message',
                            'state': 'state',
                            'deployment_progress_state': 'deployment_progress_state',
                            'host_switch_states': 'host_switch_states',
                            'maintenance_mode_state': 'maintenance_mode_state',
                            'node_deployment_state': 'node_deployment_state',
                            'remote_tunnel_endpoint_state': 'remote_tunnel_endpoint_state',
                            'transport_node_id': 'transport_node_id',
                            }

    def __init__(self,
                 details=None,
                 failure_code=None,
                 failure_message=None,
                 state=None,
                 deployment_progress_state=None,
                 host_switch_states=None,
                 maintenance_mode_state=None,
                 node_deployment_state=None,
                 remote_tunnel_endpoint_state=None,
                 transport_node_id=None,
                ):
        """
        :type  details: :class:`list` of :class:`ConfigurationStateElement` or ``None``
        :param details: Array of configuration state of various sub systems
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  failure_code: :class:`long` or ``None``
        :param failure_code: Error code format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  failure_message: :class:`str` or ``None``
        :param failure_message: Error message in case of failure
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  state: :class:`str` or ``None``
        :param state: Possible values are: 
            
            * :attr:`TransportNodeState.STATE_PENDING`
            * :attr:`TransportNodeState.STATE_IN_PROGRESS`
            * :attr:`TransportNodeState.STATE_SUCCESS`
            * :attr:`TransportNodeState.STATE_FAILED`
            * :attr:`TransportNodeState.STATE_PARTIAL_SUCCESS`
            * :attr:`TransportNodeState.STATE_ORPHANED`
            * :attr:`TransportNodeState.STATE_UNKNOWN`
            * :attr:`TransportNodeState.STATE_ERROR`
            * :attr:`TransportNodeState.STATE_IN_SYNC`
            * :attr:`TransportNodeState.STATE_NOT_AVAILABLE`
            * :attr:`TransportNodeState.STATE_VM_DEPLOYMENT_QUEUED`
            * :attr:`TransportNodeState.STATE_VM_DEPLOYMENT_IN_PROGRESS`
            * :attr:`TransportNodeState.STATE_VM_DEPLOYMENT_FAILED`
            * :attr:`TransportNodeState.STATE_VM_POWER_ON_IN_PROGRESS`
            * :attr:`TransportNodeState.STATE_VM_POWER_ON_FAILED`
            * :attr:`TransportNodeState.STATE_REGISTRATION_PENDING`
            * :attr:`TransportNodeState.STATE_NODE_NOT_READY`
            * :attr:`TransportNodeState.STATE_NODE_READY`
            * :attr:`TransportNodeState.STATE_VM_POWER_OFF_IN_PROGRESS`
            * :attr:`TransportNodeState.STATE_VM_POWER_OFF_FAILED`
            * :attr:`TransportNodeState.STATE_VM_UNDEPLOY_IN_PROGRESS`
            * :attr:`TransportNodeState.STATE_VM_UNDEPLOY_FAILED`
            * :attr:`TransportNodeState.STATE_VM_UNDEPLOY_SUCCESSFUL`
            * :attr:`TransportNodeState.STATE_EDGE_CONFIG_ERROR`
            * :attr:`TransportNodeState.STATE_VM_DEPLOYMENT_RESTARTED`
            * :attr:`TransportNodeState.STATE_REGISTRATION_FAILED`
            * :attr:`TransportNodeState.STATE_TRANSPORT_NODE_SYNC_PENDING`
            *
              :attr:`TransportNodeState.STATE_TRANSPORT_NODE_CONFIGURATION_MISSING`
            * :attr:`TransportNodeState.STATE_EDGE_HARDWARE_NOT_SUPPORTED`
            *
              :attr:`TransportNodeState.STATE_MULTIPLE_OVERLAY_TZS_NOT_SUPPORTED`
            *
              :attr:`TransportNodeState.STATE_TN_OVERLAY_TZ_IN_USE_BY_EDGE_CLUSTER`
            * :attr:`TransportNodeState.STATE_TZ_ENDPOINTS_NOT_SPECIFIED`
            * :attr:`TransportNodeState.STATE_NO_PNIC_PREPARED_IN_EDGE`
            * :attr:`TransportNodeState.STATE_APPLIANCE_INTERNAL_ERROR`
            * :attr:`TransportNodeState.STATE_VTEP_DHCP_NOT_SUPPORTED`
            * :attr:`TransportNodeState.STATE_UNSUPPORTED_HOST_SWITCH_PROFILE`
            *
              :attr:`TransportNodeState.STATE_UPLINK_HOST_SWITCH_PROFILE_NOT_SPECIFIED`
            * :attr:`TransportNodeState.STATE_HOSTSWITCH_PROFILE_NOT_FOUND`
            * :attr:`TransportNodeState.STATE_LLDP_SEND_ENABLED_NOT_SUPPORTED`
            * :attr:`TransportNodeState.STATE_UNSUPPORTED_NAMED_TEAMING_POLICY`
            *
              :attr:`TransportNodeState.STATE_LBSRCID_NOT_SUPPORTED_FOR_EDGE_VM`
            * :attr:`TransportNodeState.STATE_LACP_NOT_SUPPORTED_FOR_EDGE_VM`
            *
              :attr:`TransportNodeState.STATE_STANDBY_UPLINKS_NOT_SUPPORTED_FOR_EDGE_VM`
            *
              :attr:`TransportNodeState.STATE_MULTIPLE_ACTIVE_UPLINKS_NOT_SUPPORTED_FOR_EDGE`
            *
              :attr:`TransportNodeState.STATE_UNSUPPORTED_LACP_LB_ALGO_FOR_NODE`
            * :attr:`TransportNodeState.STATE_EDGE_NODE_VERSION_NOT_SUPPORTED`
            * :attr:`TransportNodeState.STATE_NO_PNIC_SPECIFIED_IN_TN`
            * :attr:`TransportNodeState.STATE_INVALID_PNIC_DEVICE_NAME`
            * :attr:`TransportNodeState.STATE_TRANSPORT_NODE_READY`
            * :attr:`TransportNodeState.STATE_VM_NETWORK_EDIT_PENDING`
            *
              :attr:`TransportNodeState.STATE_UNSUPPORTED_DEFAULT_TEAMING_POLICY`
            * :attr:`TransportNodeState.STATE_MPA_DISCONNECTED`
            * :attr:`TransportNodeState.STATE_VM_RENAME_PENDING`
            * :attr:`TransportNodeState.STATE_VM_CONFIG_EDIT_PENDING`
            * :attr:`TransportNodeState.STATE_VM_NETWORK_EDIT_FAILED`
            * :attr:`TransportNodeState.STATE_VM_RENAME_FAILED`
            * :attr:`TransportNodeState.STATE_VM_CONFIG_EDIT_FAILED`
            * :attr:`TransportNodeState.STATE_VM_CONFIG_DISCREPANCY`
            * :attr:`TransportNodeState.STATE_VM_NODE_REFRESH_FAILED`
            * :attr:`TransportNodeState.STATE_VM_PLACEMENT_REFRESH_FAILED`
            * :attr:`TransportNodeState.STATE_REGISTRATION_TIMEDOUT`
            
            Gives details of state of desired configuration. Additional enums
            with more details on progress/success/error states are sent for
            edge node. The success states are NODE_READY and
            TRANSPORT_NODE_READY, pending states are {VM_DEPLOYMENT_QUEUED,
            VM_DEPLOYMENT_IN_PROGRESS, REGISTRATION_PENDING} and other values
            indicate failures. \"in_sync\" state indicates that the desired
            configuration has been received by the host to which it applies,
            but is not yet in effect. When the configuration is actually in
            effect, the state will change to \"success\". Please note, failed
            state is deprecated.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  deployment_progress_state: :class:`TransportNodeDeploymentProgressState` or ``None``
        :param deployment_progress_state: Deployment progress state of transport node realization
        :type  host_switch_states: :class:`list` of :class:`HostSwitchState` or ``None``
        :param host_switch_states: States of HostSwitches on the host
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  maintenance_mode_state: :class:`str` or ``None``
        :param maintenance_mode_state: Possible values are: 
            
            * :attr:`TransportNodeState.MAINTENANCE_MODE_STATE_ENTERING`
            * :attr:`TransportNodeState.MAINTENANCE_MODE_STATE_ENABLED`
            * :attr:`TransportNodeState.MAINTENANCE_MODE_STATE_EXITING`
            * :attr:`TransportNodeState.MAINTENANCE_MODE_STATE_DISABLED`
            
             the present realized maintenance mode state
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  node_deployment_state: :class:`ConfigurationState` or ``None``
        :param node_deployment_state: Deployment status of installation
        :type  remote_tunnel_endpoint_state: :class:`RemoteTunnelEndpointConfigState` or ``None``
        :param remote_tunnel_endpoint_state: Remote tunnel endpoint configuration state
        :type  transport_node_id: :class:`str` or ``None``
        :param transport_node_id: Unique Id of the TransportNode
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.details = details
        self.failure_code = failure_code
        self.failure_message = failure_message
        self.state = state
        self.deployment_progress_state = deployment_progress_state
        self.host_switch_states = host_switch_states
        self.maintenance_mode_state = maintenance_mode_state
        self.node_deployment_state = node_deployment_state
        self.remote_tunnel_endpoint_state = remote_tunnel_endpoint_state
        self.transport_node_id = transport_node_id
        VapiStruct.__init__(self)


TransportNodeState._set_binding_type(type.StructType(
    'com.vmware.nsx.model.transport_node_state', {
        'details': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ConfigurationStateElement'))),
        'failure_code': type.OptionalType(type.IntegerType()),
        'failure_message': type.OptionalType(type.StringType()),
        'state': type.OptionalType(type.StringType()),
        'deployment_progress_state': type.OptionalType(type.ReferenceType(__name__, 'TransportNodeDeploymentProgressState')),
        'host_switch_states': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'HostSwitchState'))),
        'maintenance_mode_state': type.OptionalType(type.StringType()),
        'node_deployment_state': type.OptionalType(type.ReferenceType(__name__, 'ConfigurationState')),
        'remote_tunnel_endpoint_state': type.OptionalType(type.ReferenceType(__name__, 'RemoteTunnelEndpointConfigState')),
        'transport_node_id': type.OptionalType(type.StringType()),
    },
    TransportNodeState,
    False,
    None))



class TransportNodeStateListResult(VapiStruct):
    """
    Transport node state queries result

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`TransportNodeState` or ``None``
        :param results: Transport Node State Results
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


TransportNodeStateListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.transport_node_state_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'TransportNodeState'))),
    },
    TransportNodeStateListResult,
    False,
    None))



class TransportNodeStatus(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    MGMT_CONNECTION_STATUS_UP = "UP"
    """


    """
    MGMT_CONNECTION_STATUS_DOWN = "DOWN"
    """


    """
    STATUS_UP = "UP"
    """


    """
    STATUS_DOWN = "DOWN"
    """


    """
    STATUS_DEGRADED = "DEGRADED"
    """


    """
    STATUS_UNKNOWN = "UNKNOWN"
    """


    """



    _canonical_to_pep_names = {
                            'agent_status': 'agent_status',
                            'control_connection_status': 'control_connection_status',
                            'mgmt_connection_status': 'mgmt_connection_status',
                            'node_display_name': 'node_display_name',
                            'node_status': 'node_status',
                            'node_uuid': 'node_uuid',
                            'pnic_status': 'pnic_status',
                            'status': 'status',
                            'threat_status': 'threat_status',
                            'tunnel_status': 'tunnel_status',
                            }

    def __init__(self,
                 agent_status=None,
                 control_connection_status=None,
                 mgmt_connection_status=None,
                 node_display_name=None,
                 node_status=None,
                 node_uuid=None,
                 pnic_status=None,
                 status=None,
                 threat_status=None,
                 tunnel_status=None,
                ):
        """
        :type  agent_status: :class:`AgentStatusCount` or ``None``
        :param agent_status: NSX agents status
        :type  control_connection_status: :class:`StatusCount` or ``None``
        :param control_connection_status: Control connection status
        :type  mgmt_connection_status: :class:`str` or ``None``
        :param mgmt_connection_status: Possible values are: 
            
            * :attr:`TransportNodeStatus.MGMT_CONNECTION_STATUS_UP`
            * :attr:`TransportNodeStatus.MGMT_CONNECTION_STATUS_DOWN`
            
             Management connection status
        :type  node_display_name: :class:`str` or ``None``
        :param node_display_name: Transport node display name
        :type  node_status: :class:`NodeStatus` or ``None``
        :param node_status: Node status
        :type  node_uuid: :class:`str` or ``None``
        :param node_uuid: Transport node uuid
        :type  pnic_status: :class:`StatusCount` or ``None``
        :param pnic_status: pNIC status
        :type  status: :class:`str` or ``None``
        :param status: Possible values are: 
            
            * :attr:`TransportNodeStatus.STATUS_UP`
            * :attr:`TransportNodeStatus.STATUS_DOWN`
            * :attr:`TransportNodeStatus.STATUS_DEGRADED`
            * :attr:`TransportNodeStatus.STATUS_UNKNOWN`
            
            Roll-up status of pNIC, management connection, control connection,
            tunnel status, agent status
        :type  threat_status: :class:`ThreatStatus` or ``None``
        :param threat_status: Threat status
        :type  tunnel_status: :class:`TunnelStatusCount` or ``None``
        :param tunnel_status: Tunnel Status
        """
        self.agent_status = agent_status
        self.control_connection_status = control_connection_status
        self.mgmt_connection_status = mgmt_connection_status
        self.node_display_name = node_display_name
        self.node_status = node_status
        self.node_uuid = node_uuid
        self.pnic_status = pnic_status
        self.status = status
        self.threat_status = threat_status
        self.tunnel_status = tunnel_status
        VapiStruct.__init__(self)


TransportNodeStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.transport_node_status', {
        'agent_status': type.OptionalType(type.ReferenceType(__name__, 'AgentStatusCount')),
        'control_connection_status': type.OptionalType(type.ReferenceType(__name__, 'StatusCount')),
        'mgmt_connection_status': type.OptionalType(type.StringType()),
        'node_display_name': type.OptionalType(type.StringType()),
        'node_status': type.OptionalType(type.ReferenceType(__name__, 'NodeStatus')),
        'node_uuid': type.OptionalType(type.StringType()),
        'pnic_status': type.OptionalType(type.ReferenceType(__name__, 'StatusCount')),
        'status': type.OptionalType(type.StringType()),
        'threat_status': type.OptionalType(type.ReferenceType(__name__, 'ThreatStatus')),
        'tunnel_status': type.OptionalType(type.ReferenceType(__name__, 'TunnelStatusCount')),
    },
    TransportNodeStatus,
    False,
    None))



class TransportNodeStatusListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`TransportNodeStatus` or ``None``
        :param results: List of transport node statuses
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


TransportNodeStatusListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.transport_node_status_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'TransportNodeStatus'))),
    },
    TransportNodeStatusListResult,
    False,
    None))



class TransportProtocolHeader(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'dhcp_header': 'dhcp_header',
                            'dhcpv6_header': 'dhcpv6_header',
                            'dns_header': 'dns_header',
                            'icmp_echo_request_header': 'icmp_echo_request_header',
                            'ndp_header': 'ndp_header',
                            'tcp_header': 'tcp_header',
                            'udp_header': 'udp_header',
                            }

    def __init__(self,
                 dhcp_header=None,
                 dhcpv6_header=None,
                 dns_header=None,
                 icmp_echo_request_header=None,
                 ndp_header=None,
                 tcp_header=None,
                 udp_header=None,
                ):
        """
        :type  dhcp_header: :class:`DhcpHeader` or ``None``
        :param dhcp_header: DHCP header
        :type  dhcpv6_header: :class:`Dhcpv6Header` or ``None``
        :param dhcpv6_header: DHCP v6 header
        :type  dns_header: :class:`DnsHeader` or ``None``
        :param dns_header: DNS header
        :type  icmp_echo_request_header: :class:`IcmpEchoRequestHeader` or ``None``
        :param icmp_echo_request_header: ICMP echo request header
        :type  ndp_header: :class:`NdpHeader` or ``None``
        :param ndp_header: Neighbor discovery protocol header
        :type  tcp_header: :class:`TcpHeader` or ``None``
        :param tcp_header: TCP header
        :type  udp_header: :class:`UdpHeader` or ``None``
        :param udp_header: UDP header
        """
        self.dhcp_header = dhcp_header
        self.dhcpv6_header = dhcpv6_header
        self.dns_header = dns_header
        self.icmp_echo_request_header = icmp_echo_request_header
        self.ndp_header = ndp_header
        self.tcp_header = tcp_header
        self.udp_header = udp_header
        VapiStruct.__init__(self)


TransportProtocolHeader._set_binding_type(type.StructType(
    'com.vmware.nsx.model.transport_protocol_header', {
        'dhcp_header': type.OptionalType(type.ReferenceType(__name__, 'DhcpHeader')),
        'dhcpv6_header': type.OptionalType(type.ReferenceType(__name__, 'Dhcpv6Header')),
        'dns_header': type.OptionalType(type.ReferenceType(__name__, 'DnsHeader')),
        'icmp_echo_request_header': type.OptionalType(type.ReferenceType(__name__, 'IcmpEchoRequestHeader')),
        'ndp_header': type.OptionalType(type.ReferenceType(__name__, 'NdpHeader')),
        'tcp_header': type.OptionalType(type.ReferenceType(__name__, 'TcpHeader')),
        'udp_header': type.OptionalType(type.ReferenceType(__name__, 'UdpHeader')),
    },
    TransportProtocolHeader,
    False,
    None))



class TransportZone(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    HOST_SWITCH_MODE_STANDARD = "STANDARD"
    """


    """
    HOST_SWITCH_MODE_ENS = "ENS"
    """


    """
    TRANSPORT_TYPE_OVERLAY = "OVERLAY"
    """


    """
    TRANSPORT_TYPE_VLAN = "VLAN"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'host_switch_id': 'host_switch_id',
                            'host_switch_mode': 'host_switch_mode',
                            'host_switch_name': 'host_switch_name',
                            'is_default': 'is_default',
                            'nested_nsx': 'nested_nsx',
                            'transport_type': 'transport_type',
                            'transport_zone_profile_ids': 'transport_zone_profile_ids',
                            'uplink_teaming_policy_names': 'uplink_teaming_policy_names',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 host_switch_id=None,
                 host_switch_mode=None,
                 host_switch_name=None,
                 is_default=None,
                 nested_nsx=None,
                 transport_type=None,
                 transport_zone_profile_ids=None,
                 uplink_teaming_policy_names=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  host_switch_id: :class:`str` or ``None``
        :param host_switch_id: The host switch id generated by the system.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  host_switch_mode: :class:`str` or ``None``
        :param host_switch_mode: Possible values are: 
            
            * :attr:`TransportZone.HOST_SWITCH_MODE_STANDARD`
            * :attr:`TransportZone.HOST_SWITCH_MODE_ENS`
            
            STANDARD mode applies to all the hypervisors. ENS mode stands for
            Enhanced Networking Stack. This feature is only available for ESX
            hypervisor. It is not available on KVM, EDGE and Public Cloud
            Gateway etc. When a Transport Zone mode is set to ENS, only
            Transport Nodes of type ESX can participate in such a Transport
            Zone.
        :type  host_switch_name: :class:`str` or ``None``
        :param host_switch_name: If this name is unset or empty then the default host switch name
            will be used.
        :type  is_default: :class:`bool` or ``None``
        :param is_default: Only one transport zone can be the default one for a given
            transport zone type. APIs that need transport zone can choose to
            use the default transport zone if a transport zone is not given.
        :type  nested_nsx: :class:`bool` or ``None``
        :param nested_nsx: This flag should be set to true in nested NSX environment. When the
            \"allow_changing_vdr_mac_in_use\" property in the global config
            object RoutingGlobalConfig is false, this flag can not be changed
            if this transport zone is OVERLAY and the change will make any
            transport node in this transport zone to change the VDR MAC used in
            any host switch. When this flag is true and this transport zone is
            OVERLAY, all host switches in this transport zone will use the VDR
            MAC in the \"vdr_mac_nested\" property in the global config object
            RoutingGlobalConfig.
        :type  transport_type: :class:`str` or ``None``
        :param transport_type: Possible values are: 
            
            * :attr:`TransportZone.TRANSPORT_TYPE_OVERLAY`
            * :attr:`TransportZone.TRANSPORT_TYPE_VLAN`
            
             The transport type of this transport zone.
        :type  transport_zone_profile_ids: :class:`list` of :class:`TransportZoneProfileTypeIdEntry` or ``None``
        :param transport_zone_profile_ids: Identifiers of the transport zone profiles associated with this
            TransportZone.
        :type  uplink_teaming_policy_names: :class:`list` of :class:`str` or ``None``
        :param uplink_teaming_policy_names: The names of switching uplink teaming policies that all transport
            nodes in this transport zone must support. An exception will be
            thrown if a transport node within the transport zone does not
            support a named teaming policy. The user will need to first ensure
            all trasnport nodes support the desired named teaming policy before
            assigning it to the transport zone. If the field is not specified,
            the host switch's default teaming policy will be used.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.host_switch_id = host_switch_id
        self.host_switch_mode = host_switch_mode
        self.host_switch_name = host_switch_name
        self.is_default = is_default
        self.nested_nsx = nested_nsx
        self.transport_type = transport_type
        self.transport_zone_profile_ids = transport_zone_profile_ids
        self.uplink_teaming_policy_names = uplink_teaming_policy_names
        VapiStruct.__init__(self)


TransportZone._set_binding_type(type.StructType(
    'com.vmware.nsx.model.transport_zone', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'host_switch_id': type.OptionalType(type.StringType()),
        'host_switch_mode': type.OptionalType(type.StringType()),
        'host_switch_name': type.OptionalType(type.StringType()),
        'is_default': type.OptionalType(type.BooleanType()),
        'nested_nsx': type.OptionalType(type.BooleanType()),
        'transport_type': type.OptionalType(type.StringType()),
        'transport_zone_profile_ids': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'TransportZoneProfileTypeIdEntry'))),
        'uplink_teaming_policy_names': type.OptionalType(type.ListType(type.StringType())),
    },
    TransportZone,
    False,
    None))



class TransportZoneEndPoint(VapiStruct):
    """
    Specify which HostSwitch from this TransportNode is used handle traffic for
    given TransportZone

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'transport_zone_id': 'transport_zone_id',
                            'transport_zone_profile_ids': 'transport_zone_profile_ids',
                            }

    def __init__(self,
                 transport_zone_id=None,
                 transport_zone_profile_ids=None,
                ):
        """
        :type  transport_zone_id: :class:`str` or ``None``
        :param transport_zone_id: Unique ID identifying the transport zone for this endpoint
        :type  transport_zone_profile_ids: :class:`list` of :class:`TransportZoneProfileTypeIdEntry` or ``None``
        :param transport_zone_profile_ids: Identifiers of the transport zone profiles associated with this
            transport zone endpoint on this transport node.
        """
        self.transport_zone_id = transport_zone_id
        self.transport_zone_profile_ids = transport_zone_profile_ids
        VapiStruct.__init__(self)


TransportZoneEndPoint._set_binding_type(type.StructType(
    'com.vmware.nsx.model.transport_zone_end_point', {
        'transport_zone_id': type.OptionalType(type.StringType()),
        'transport_zone_profile_ids': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'TransportZoneProfileTypeIdEntry'))),
    },
    TransportZoneEndPoint,
    False,
    None))



class TransportZoneListResult(VapiStruct):
    """
    Transport zone queries result

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`TransportZone` or ``None``
        :param results: Transport Zone Results
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


TransportZoneListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.transport_zone_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'TransportZone'))),
    },
    TransportZoneListResult,
    False,
    None))



class TransportZoneProfile(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "TransportZoneProfile"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    RESOURCE_TYPE_BFDHEALTHMONITORINGPROFILE = "BfdHealthMonitoringProfile"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='TransportZoneProfile',
                 tags=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            *
              :attr:`TransportZoneProfile.RESOURCE_TYPE_BFDHEALTHMONITORINGPROFILE`
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

TransportZoneProfile._set_binding_type(type.StructType(
    'com.vmware.nsx.model.transport_zone_profile', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
    },
    TransportZoneProfile,
    False,
    None))



class TransportZoneProfileListResult(VapiStruct):
    """
    Transport zone profile queries result

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param results: Transport zone profile results
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`TransportZoneProfile`. When methods return a value of this
            class as a return value, the attribute will contain all the
            attributes defined in :class:`TransportZoneProfile`.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


TransportZoneProfileListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.transport_zone_profile_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'TransportZoneProfile')]))),
    },
    TransportZoneProfileListResult,
    False,
    None))



class TransportZoneProfileTypeIdEntry(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    RESOURCE_TYPE_BFDHEALTHMONITORINGPROFILE = "BfdHealthMonitoringProfile"
    """


    """



    _canonical_to_pep_names = {
                            'profile_id': 'profile_id',
                            'resource_type': 'resource_type',
                            }

    def __init__(self,
                 profile_id=None,
                 resource_type=None,
                ):
        """
        :type  profile_id: :class:`str` or ``None``
        :param profile_id: profile id of the resource type
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: Possible values are: 
            
            *
              :attr:`TransportZoneProfileTypeIdEntry.RESOURCE_TYPE_BFDHEALTHMONITORINGPROFILE`
            
             Selects the type of the transport zone profile
        """
        self.profile_id = profile_id
        self.resource_type = resource_type
        VapiStruct.__init__(self)


TransportZoneProfileTypeIdEntry._set_binding_type(type.StructType(
    'com.vmware.nsx.model.transport_zone_profile_type_id_entry', {
        'profile_id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
    },
    TransportZoneProfileTypeIdEntry,
    False,
    None))



class TransportZoneStatus(VapiStruct):
    """
    Transport zone runtime status information

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'num_logical_ports': 'num_logical_ports',
                            'num_logical_switches': 'num_logical_switches',
                            'num_transport_nodes': 'num_transport_nodes',
                            'transport_node_members': 'transport_node_members',
                            'transport_zone_id': 'transport_zone_id',
                            }

    def __init__(self,
                 num_logical_ports=None,
                 num_logical_switches=None,
                 num_transport_nodes=None,
                 transport_node_members=None,
                 transport_zone_id=None,
                ):
        """
        :type  num_logical_ports: :class:`long` or ``None``
        :param num_logical_ports: Count of logical ports in the transport zone format: int32
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  num_logical_switches: :class:`long` or ``None``
        :param num_logical_switches: Count of logical switches in the transport zone format: int32
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  num_transport_nodes: :class:`long` or ``None``
        :param num_transport_nodes: Count of transport nodes in the transport zone format: int32
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  transport_node_members: :class:`list` of :class:`TransportNodeMemberInfo` or ``None``
        :param transport_node_members: Information about transport nodes which are part of this transport
            zone
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  transport_zone_id: :class:`str` or ``None``
        :param transport_zone_id: Unique ID identifying the transport zone
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.num_logical_ports = num_logical_ports
        self.num_logical_switches = num_logical_switches
        self.num_transport_nodes = num_transport_nodes
        self.transport_node_members = transport_node_members
        self.transport_zone_id = transport_zone_id
        VapiStruct.__init__(self)


TransportZoneStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.transport_zone_status', {
        'num_logical_ports': type.OptionalType(type.IntegerType()),
        'num_logical_switches': type.OptionalType(type.IntegerType()),
        'num_transport_nodes': type.OptionalType(type.IntegerType()),
        'transport_node_members': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'TransportNodeMemberInfo'))),
        'transport_zone_id': type.OptionalType(type.StringType()),
    },
    TransportZoneStatus,
    False,
    None))



class TrunkVlanRange(VapiStruct):
    """
    Trunk VLAN id range

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'end': 'end',
                            'start': 'start',
                            }

    def __init__(self,
                 end=None,
                 start=None,
                ):
        """
        :type  end: :class:`long` or ``None``
        :param end: Virtual Local Area Network Identifier format: int64
        :type  start: :class:`long` or ``None``
        :param start: Virtual Local Area Network Identifier format: int64
        """
        self.end = end
        self.start = start
        VapiStruct.__init__(self)


TrunkVlanRange._set_binding_type(type.StructType(
    'com.vmware.nsx.model.trunk_vlan_range', {
        'end': type.OptionalType(type.IntegerType()),
        'start': type.OptionalType(type.IntegerType()),
    },
    TrunkVlanRange,
    False,
    None))



class TrustManagementData(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'supported_algorithms': 'supported_algorithms',
                            }

    def __init__(self,
                 supported_algorithms=None,
                ):
        """
        :type  supported_algorithms: :class:`list` of :class:`CryptoAlgorithm` or ``None``
        :param supported_algorithms: List of supported algorithms.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.supported_algorithms = supported_algorithms
        VapiStruct.__init__(self)


TrustManagementData._set_binding_type(type.StructType(
    'com.vmware.nsx.model.trust_management_data', {
        'supported_algorithms': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'CryptoAlgorithm'))),
    },
    TrustManagementData,
    False,
    None))



class TrustObjectData(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'key_algo': 'key_algo',
                            'passphrase': 'passphrase',
                            'pem_encoded': 'pem_encoded',
                            'private_key': 'private_key',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 key_algo=None,
                 passphrase=None,
                 pem_encoded=None,
                 private_key=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  key_algo: :class:`str` or ``None``
        :param key_algo: Key algorithm contained in this certificate.
        :type  passphrase: :class:`str` or ``None``
        :param passphrase: Password for private key encryption.
        :type  pem_encoded: :class:`str` or ``None``
        :param pem_encoded: PEM encoded certificate data.
        :type  private_key: :class:`str` or ``None``
        :param private_key: Private key data.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.key_algo = key_algo
        self.passphrase = passphrase
        self.pem_encoded = pem_encoded
        self.private_key = private_key
        VapiStruct.__init__(self)


TrustObjectData._set_binding_type(type.StructType(
    'com.vmware.nsx.model.trust_object_data', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'key_algo': type.OptionalType(type.StringType()),
        'passphrase': type.OptionalType(type.StringType()),
        'pem_encoded': type.OptionalType(type.StringType()),
        'private_key': type.OptionalType(type.StringType()),
    },
    TrustObjectData,
    False,
    None))



class TunnelList(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'tunnels': 'tunnels',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 tunnels=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  tunnels: :class:`list` of :class:`TunnelProperties` or ``None``
        :param tunnels: List of transport node tunnels
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.tunnels = tunnels
        VapiStruct.__init__(self)


TunnelList._set_binding_type(type.StructType(
    'com.vmware.nsx.model.tunnel_list', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'tunnels': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'TunnelProperties'))),
    },
    TunnelList,
    False,
    None))



class TunnelPortConfig(VapiStruct):
    """
    IP Tunnel port configuration.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'ip_subnets': 'ip_subnets',
                            'tunnel_port_id': 'tunnel_port_id',
                            }

    def __init__(self,
                 ip_subnets=None,
                 tunnel_port_id=None,
                ):
        """
        :type  ip_subnets: :class:`list` of :class:`IPSubnet` or ``None``
        :param ip_subnets: IP Tunnel port (commonly referred as VTI) subnet.
        :type  tunnel_port_id: :class:`str` or ``None``
        :param tunnel_port_id: Logical route port identifier.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.ip_subnets = ip_subnets
        self.tunnel_port_id = tunnel_port_id
        VapiStruct.__init__(self)


TunnelPortConfig._set_binding_type(type.StructType(
    'com.vmware.nsx.model.tunnel_port_config', {
        'ip_subnets': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IPSubnet'))),
        'tunnel_port_id': type.OptionalType(type.StringType()),
    },
    TunnelPortConfig,
    False,
    None))



class TunnelProperties(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    ENCAP_STT = "STT"
    """


    """
    ENCAP_VXLAN = "VXLAN"
    """


    """
    ENCAP_GENEVE = "GENEVE"
    """


    """
    ENCAP_UNKNOWN_ENCAP = "UNKNOWN_ENCAP"
    """


    """
    LATENCY_TYPE_UNKNOWN_LATENCY = "UNKNOWN_LATENCY"
    """


    """
    LATENCY_TYPE_VALID = "VALID"
    """


    """
    LATENCY_TYPE_NOT_READY = "NOT_READY"
    """


    """
    LATENCY_TYPE_TIMEOUT = "TIMEOUT"
    """


    """
    STATUS_UP = "UP"
    """


    """
    STATUS_DOWN = "DOWN"
    """


    """
    STATUS_UNKNOWN = "UNKNOWN"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'bfd': 'bfd',
                            'egress_interface': 'egress_interface',
                            'encap': 'encap',
                            'last_updated_time': 'last_updated_time',
                            'latency_type': 'latency_type',
                            'latency_value': 'latency_value',
                            'local_ip': 'local_ip',
                            'name': 'name',
                            'remote_ip': 'remote_ip',
                            'remote_node_display_name': 'remote_node_display_name',
                            'remote_node_id': 'remote_node_id',
                            'status': 'status',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 bfd=None,
                 egress_interface=None,
                 encap=None,
                 last_updated_time=None,
                 latency_type=None,
                 latency_value=None,
                 local_ip=None,
                 name=None,
                 remote_ip=None,
                 remote_node_display_name=None,
                 remote_node_id=None,
                 status=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  bfd: :class:`BFDProperties` or ``None``
        :param bfd: Detailed information about BFD configured on interface
        :type  egress_interface: :class:`str` or ``None``
        :param egress_interface: Corresponds to the interface where local_ip_address is routed.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  encap: :class:`str` or ``None``
        :param encap: Possible values are: 
            
            * :attr:`TunnelProperties.ENCAP_STT`
            * :attr:`TunnelProperties.ENCAP_VXLAN`
            * :attr:`TunnelProperties.ENCAP_GENEVE`
            * :attr:`TunnelProperties.ENCAP_UNKNOWN_ENCAP`
            
             Tunnel encap
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_updated_time: :class:`long` or ``None``
        :param last_updated_time: Time at which the Tunnel status has been fetched last time. format:
            int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  latency_type: :class:`str` or ``None``
        :param latency_type: Possible values are: 
            
            * :attr:`TunnelProperties.LATENCY_TYPE_UNKNOWN_LATENCY`
            * :attr:`TunnelProperties.LATENCY_TYPE_VALID`
            * :attr:`TunnelProperties.LATENCY_TYPE_NOT_READY`
            * :attr:`TunnelProperties.LATENCY_TYPE_TIMEOUT`
            
             Latency type.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  latency_value: :class:`long` or ``None``
        :param latency_value: The latency value is set only when latency_type is VALID. format:
            int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  local_ip: :class:`str` or ``None``
        :param local_ip: Local IP address of tunnel format: ip
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  name: :class:`str` or ``None``
        :param name: Name of tunnel
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  remote_ip: :class:`str` or ``None``
        :param remote_ip: Remote IP address of tunnel format: ip
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  remote_node_display_name: :class:`str` or ``None``
        :param remote_node_display_name: Represents the display name of the remote transport node at the
            other end of the tunnel.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  remote_node_id: :class:`str` or ``None``
        :param remote_node_id: UUID of the remote transport node
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  status: :class:`str` or ``None``
        :param status: Possible values are: 
            
            * :attr:`TunnelProperties.STATUS_UP`
            * :attr:`TunnelProperties.STATUS_DOWN`
            * :attr:`TunnelProperties.STATUS_UNKNOWN`
            
             Status of tunnel
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.bfd = bfd
        self.egress_interface = egress_interface
        self.encap = encap
        self.last_updated_time = last_updated_time
        self.latency_type = latency_type
        self.latency_value = latency_value
        self.local_ip = local_ip
        self.name = name
        self.remote_ip = remote_ip
        self.remote_node_display_name = remote_node_display_name
        self.remote_node_id = remote_node_id
        self.status = status
        VapiStruct.__init__(self)


TunnelProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.tunnel_properties', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'bfd': type.OptionalType(type.ReferenceType(__name__, 'BFDProperties')),
        'egress_interface': type.OptionalType(type.StringType()),
        'encap': type.OptionalType(type.StringType()),
        'last_updated_time': type.OptionalType(type.IntegerType()),
        'latency_type': type.OptionalType(type.StringType()),
        'latency_value': type.OptionalType(type.IntegerType()),
        'local_ip': type.OptionalType(type.StringType()),
        'name': type.OptionalType(type.StringType()),
        'remote_ip': type.OptionalType(type.StringType()),
        'remote_node_display_name': type.OptionalType(type.StringType()),
        'remote_node_id': type.OptionalType(type.StringType()),
        'status': type.OptionalType(type.StringType()),
    },
    TunnelProperties,
    False,
    None))



class TunnelStatusCount(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATUS_UP = "UP"
    """


    """
    STATUS_DOWN = "DOWN"
    """


    """
    STATUS_DEGRADED = "DEGRADED"
    """


    """
    STATUS_UNKNOWN = "UNKNOWN"
    """


    """



    _canonical_to_pep_names = {
                            'degraded_count': 'degraded_count',
                            'down_count': 'down_count',
                            'status': 'status',
                            'up_count': 'up_count',
                            'bfd_diagnostic': 'bfd_diagnostic',
                            'bfd_status': 'bfd_status',
                            }

    def __init__(self,
                 degraded_count=None,
                 down_count=None,
                 status=None,
                 up_count=None,
                 bfd_diagnostic=None,
                 bfd_status=None,
                ):
        """
        :type  degraded_count: :class:`long` or ``None``
        :param degraded_count: Degraded count format: int32
        :type  down_count: :class:`long` or ``None``
        :param down_count: Down count format: int32
        :type  status: :class:`str` or ``None``
        :param status: Possible values are: 
            
            * :attr:`TunnelStatusCount.STATUS_UP`
            * :attr:`TunnelStatusCount.STATUS_DOWN`
            * :attr:`TunnelStatusCount.STATUS_DEGRADED`
            * :attr:`TunnelStatusCount.STATUS_UNKNOWN`
            
             Roll-up status
        :type  up_count: :class:`long` or ``None``
        :param up_count: Up count format: int32
        :type  bfd_diagnostic: :class:`BFDDiagnosticCount` or ``None``
        :param bfd_diagnostic: BFD Diagnostic
        :type  bfd_status: :class:`BFDStatusCount` or ``None``
        :param bfd_status: BFD Status
        """
        self.degraded_count = degraded_count
        self.down_count = down_count
        self.status = status
        self.up_count = up_count
        self.bfd_diagnostic = bfd_diagnostic
        self.bfd_status = bfd_status
        VapiStruct.__init__(self)


TunnelStatusCount._set_binding_type(type.StructType(
    'com.vmware.nsx.model.tunnel_status_count', {
        'degraded_count': type.OptionalType(type.IntegerType()),
        'down_count': type.OptionalType(type.IntegerType()),
        'status': type.OptionalType(type.StringType()),
        'up_count': type.OptionalType(type.IntegerType()),
        'bfd_diagnostic': type.OptionalType(type.ReferenceType(__name__, 'BFDDiagnosticCount')),
        'bfd_status': type.OptionalType(type.ReferenceType(__name__, 'BFDStatusCount')),
    },
    TunnelStatusCount,
    False,
    None))



class UcFunctionalState(VapiStruct):
    """
    Upgrade coordinator Uc functional State.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATE_RUNNING = "RUNNING"
    """


    """
    STATE_STANDBY = "STANDBY"
    """


    """



    _canonical_to_pep_names = {
                            'error_message': 'error_message',
                            'state': 'state',
                            }

    def __init__(self,
                 error_message=None,
                 state=None,
                ):
        """
        :type  error_message: :class:`str` or ``None``
        :param error_message: error message that explains why UC is on standby mode.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  state: :class:`str` or ``None``
        :param state: Possible values are: 
            
            * :attr:`UcFunctionalState.STATE_RUNNING`
            * :attr:`UcFunctionalState.STATE_STANDBY`
            
             function state of the upgrade coordinator
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.error_message = error_message
        self.state = state
        VapiStruct.__init__(self)


UcFunctionalState._set_binding_type(type.StructType(
    'com.vmware.nsx.model.uc_functional_state', {
        'error_message': type.OptionalType(type.StringType()),
        'state': type.OptionalType(type.StringType()),
    },
    UcFunctionalState,
    False,
    None))



class UcStateProperties(VapiStruct):
    """
    Upgrade Coordinator state properties

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'update_uc_state_properties': 'update_uc_state_properties',
                            }

    def __init__(self,
                 update_uc_state_properties=None,
                ):
        """
        :type  update_uc_state_properties: :class:`bool` or ``None``
        :param update_uc_state_properties: Flag for updating upgrade-coodinator state properties to database
        """
        self.update_uc_state_properties = update_uc_state_properties
        VapiStruct.__init__(self)


UcStateProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.uc_state_properties', {
        'update_uc_state_properties': type.OptionalType(type.BooleanType()),
    },
    UcStateProperties,
    False,
    None))



class UcUpgradeStatus(VapiStruct):
    """
    Upgrade status of upgrade-coordinator

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATE_NOT_STARTED = "NOT_STARTED"
    """


    """
    STATE_IN_PROGRESS = "IN_PROGRESS"
    """


    """
    STATE_SUCCESS = "SUCCESS"
    """


    """
    STATE_FAILED = "FAILED"
    """


    """



    _canonical_to_pep_names = {
                            'state': 'state',
                            'status': 'status',
                            }

    def __init__(self,
                 state=None,
                 status=None,
                ):
        """
        :type  state: :class:`str` or ``None``
        :param state: Possible values are: 
            
            * :attr:`UcUpgradeStatus.STATE_NOT_STARTED`
            * :attr:`UcUpgradeStatus.STATE_IN_PROGRESS`
            * :attr:`UcUpgradeStatus.STATE_SUCCESS`
            * :attr:`UcUpgradeStatus.STATE_FAILED`
            
             Current state of UC upgrade
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  status: :class:`str` or ``None``
        :param status: Status of UC upgrade
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.state = state
        self.status = status
        VapiStruct.__init__(self)


UcUpgradeStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.uc_upgrade_status', {
        'state': type.OptionalType(type.StringType()),
        'status': type.OptionalType(type.StringType()),
    },
    UcUpgradeStatus,
    False,
    None))



class UdpHeader(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'dst_port': 'dst_port',
                            'src_port': 'src_port',
                            }

    def __init__(self,
                 dst_port=None,
                 src_port=None,
                ):
        """
        :type  dst_port: :class:`long` or ``None``
        :param dst_port: Destination port of udp header format: int64
        :type  src_port: :class:`long` or ``None``
        :param src_port: Source port of udp header format: int64
        """
        self.dst_port = dst_port
        self.src_port = src_port
        VapiStruct.__init__(self)


UdpHeader._set_binding_type(type.StructType(
    'com.vmware.nsx.model.udp_header', {
        'dst_port': type.OptionalType(type.IntegerType()),
        'src_port': type.OptionalType(type.IntegerType()),
    },
    UdpHeader,
    False,
    None))



class UnassociatedVMListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'last_update_timestamp': 'last_update_timestamp',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 last_update_timestamp=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_update_timestamp: :class:`long` or ``None``
        :param last_update_timestamp: Timestamp in milliseconds since epoch format: int64
        :type  results: :class:`list` of :class:`VirtualMachine` or ``None``
        :param results: List of VMs which are not associated with any NSGroup
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.last_update_timestamp = last_update_timestamp
        self.results = results
        VapiStruct.__init__(self)


UnassociatedVMListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.unassociated_VM_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'last_update_timestamp': type.OptionalType(type.IntegerType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'VirtualMachine'))),
    },
    UnassociatedVMListResult,
    False,
    None))



class UnboundedKeyValuePair(VapiStruct):
    """
    A key-value pair with no limitations on size

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'key': 'key',
                            'value': 'value',
                            }

    def __init__(self,
                 key=None,
                 value=None,
                ):
        """
        :type  key: :class:`str` or ``None``
        :param key: Key
        :type  value: :class:`str` or ``None``
        :param value: Value
        """
        self.key = key
        self.value = value
        VapiStruct.__init__(self)


UnboundedKeyValuePair._set_binding_type(type.StructType(
    'com.vmware.nsx.model.unbounded_key_value_pair', {
        'key': type.OptionalType(type.StringType()),
        'value': type.OptionalType(type.StringType()),
    },
    UnboundedKeyValuePair,
    False,
    None))



class UnidirectionalServicePath(VapiStruct):
    """
    Representing either forward or reverse service path for ingress or egress
    traffic respectively.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'hops': 'hops',
                            'host_cross_count': 'host_cross_count',
                            'in_maintenance_mode': 'in_maintenance_mode',
                            'is_active': 'is_active',
                            'unidir_service_path_id': 'unidir_service_path_id',
                            }

    def __init__(self,
                 hops=None,
                 host_cross_count=None,
                 in_maintenance_mode=None,
                 is_active=None,
                 unidir_service_path_id=None,
                ):
        """
        :type  hops: :class:`list` of :class:`ServicePathHop` or ``None``
        :param hops: List of service path hops that constitutes the forward or reverse
            service path.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  host_cross_count: :class:`long` or ``None``
        :param host_cross_count: The number of times the traffic needs to cross hosts for the given
            forward or reverse service path. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  in_maintenance_mode: :class:`bool` or ``None``
        :param in_maintenance_mode: Is forward or revserse service path in maintenance mode or not.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  is_active: :class:`bool` or ``None``
        :param is_active: Is forward or revserse service path active or not.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  unidir_service_path_id: :class:`long` or ``None``
        :param unidir_service_path_id: Unique identifier of one directional service path. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.hops = hops
        self.host_cross_count = host_cross_count
        self.in_maintenance_mode = in_maintenance_mode
        self.is_active = is_active
        self.unidir_service_path_id = unidir_service_path_id
        VapiStruct.__init__(self)


UnidirectionalServicePath._set_binding_type(type.StructType(
    'com.vmware.nsx.model.unidirectional_service_path', {
        'hops': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ServicePathHop'))),
        'host_cross_count': type.OptionalType(type.IntegerType()),
        'in_maintenance_mode': type.OptionalType(type.BooleanType()),
        'is_active': type.OptionalType(type.BooleanType()),
        'unidir_service_path_id': type.OptionalType(type.IntegerType()),
    },
    UnidirectionalServicePath,
    False,
    None))



class UpdateOidcEndPointThumbprintRequest(VapiStruct):
    """
    Request to update the thumbprint of an OpenID Connect end-point with a new
    thumbprint.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'oidc_uri': 'oidc_uri',
                            'thumbprint': 'thumbprint',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 oidc_uri=None,
                 thumbprint=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  oidc_uri: :class:`str` or ``None``
        :param oidc_uri: URI where to download the meta-data of the OIDC end-point.
        :type  thumbprint: :class:`str` or ``None``
        :param thumbprint: Thumbprint of the OIDC URI to make an SSL connection.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.oidc_uri = oidc_uri
        self.thumbprint = thumbprint
        VapiStruct.__init__(self)


UpdateOidcEndPointThumbprintRequest._set_binding_type(type.StructType(
    'com.vmware.nsx.model.update_oidc_end_point_thumbprint_request', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'oidc_uri': type.OptionalType(type.StringType()),
        'thumbprint': type.OptionalType(type.StringType()),
    },
    UpdateOidcEndPointThumbprintRequest,
    False,
    None))



class UpdatePrincipalIdentityCertificateRequest(VapiStruct):
    """
    Request to update the certificate of a principal identity with a new
    certificate.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'certificate_id': 'certificate_id',
                            'principal_identity_id': 'principal_identity_id',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 certificate_id=None,
                 principal_identity_id=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  certificate_id: :class:`str` or ``None``
        :param certificate_id: Id of the stored certificate.
        :type  principal_identity_id: :class:`str` or ``None``
        :param principal_identity_id: Unique ID of the principal.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.certificate_id = certificate_id
        self.principal_identity_id = principal_identity_id
        VapiStruct.__init__(self)


UpdatePrincipalIdentityCertificateRequest._set_binding_type(type.StructType(
    'com.vmware.nsx.model.update_principal_identity_certificate_request', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'certificate_id': type.OptionalType(type.StringType()),
        'principal_identity_id': type.OptionalType(type.StringType()),
    },
    UpdatePrincipalIdentityCertificateRequest,
    False,
    None))



class UpgradeBundleFetchRequest(VapiStruct):
    """
    URL and other fetch requests of upgrade bundle

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'url': 'url',
                            }

    def __init__(self,
                 url=None,
                ):
        """
        :type  url: :class:`str` or ``None``
        :param url: URL for uploading upgrade bundle
        """
        self.url = url
        VapiStruct.__init__(self)


UpgradeBundleFetchRequest._set_binding_type(type.StructType(
    'com.vmware.nsx.model.upgrade_bundle_fetch_request', {
        'url': type.OptionalType(type.StringType()),
    },
    UpgradeBundleFetchRequest,
    False,
    None))



class UpgradeBundleId(VapiStruct):
    """
    Identifier of the upgrade bundle

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'bundle_id': 'bundle_id',
                            }

    def __init__(self,
                 bundle_id=None,
                ):
        """
        :type  bundle_id: :class:`str` or ``None``
        :param bundle_id: Identifier of bundle upload
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.bundle_id = bundle_id
        VapiStruct.__init__(self)


UpgradeBundleId._set_binding_type(type.StructType(
    'com.vmware.nsx.model.upgrade_bundle_id', {
        'bundle_id': type.OptionalType(type.StringType()),
    },
    UpgradeBundleId,
    False,
    None))



class UpgradeBundleInfo(VapiStruct):
    """
    Information about the upgrade bundle

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'bundle_size': 'bundle_size',
                            'url': 'url',
                            }

    def __init__(self,
                 bundle_size=None,
                 url=None,
                ):
        """
        :type  bundle_size: :class:`str` or ``None``
        :param bundle_size: size of upgrade bundle
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  url: :class:`str` or ``None``
        :param url: URL for uploading upgrade bundle
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.bundle_size = bundle_size
        self.url = url
        VapiStruct.__init__(self)


UpgradeBundleInfo._set_binding_type(type.StructType(
    'com.vmware.nsx.model.upgrade_bundle_info', {
        'bundle_size': type.OptionalType(type.StringType()),
        'url': type.OptionalType(type.StringType()),
    },
    UpgradeBundleInfo,
    False,
    None))



class UpgradeBundleUploadStatus(VapiStruct):
    """
    Upload status of upgrade bundle uploaded from url

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATUS_UPLOADING = "UPLOADING"
    """


    """
    STATUS_VERIFYING = "VERIFYING"
    """


    """
    STATUS_SUCCESS = "SUCCESS"
    """


    """
    STATUS_FAILED = "FAILED"
    """


    """



    _canonical_to_pep_names = {
                            'detailed_status': 'detailed_status',
                            'percent': 'percent',
                            'status': 'status',
                            'url': 'url',
                            }

    def __init__(self,
                 detailed_status=None,
                 percent=None,
                 status=None,
                 url=None,
                ):
        """
        :type  detailed_status: :class:`str` or ``None``
        :param detailed_status: Detailed status of upgrade bundle upload
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  percent: :class:`float` or ``None``
        :param percent: Percent of bundle uploaded from URL
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  status: :class:`str` or ``None``
        :param status: Possible values are: 
            
            * :attr:`UpgradeBundleUploadStatus.STATUS_UPLOADING`
            * :attr:`UpgradeBundleUploadStatus.STATUS_VERIFYING`
            * :attr:`UpgradeBundleUploadStatus.STATUS_SUCCESS`
            * :attr:`UpgradeBundleUploadStatus.STATUS_FAILED`
            
             Current status of upgrade bundle upload
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  url: :class:`str` or ``None``
        :param url: URL for uploading upgrade bundle
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.detailed_status = detailed_status
        self.percent = percent
        self.status = status
        self.url = url
        VapiStruct.__init__(self)


UpgradeBundleUploadStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.upgrade_bundle_upload_status', {
        'detailed_status': type.OptionalType(type.StringType()),
        'percent': type.OptionalType(type.DoubleType()),
        'status': type.OptionalType(type.StringType()),
        'url': type.OptionalType(type.StringType()),
    },
    UpgradeBundleUploadStatus,
    False,
    None))



class UpgradeCheck(VapiStruct):
    """
    Check to identify potential pre/post-upgrade issues

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATUS_SUCCESS = "SUCCESS"
    """


    """
    STATUS_FAILURE = "FAILURE"
    """


    """
    STATUS_WARNING = "WARNING"
    """


    """



    _canonical_to_pep_names = {
                            'component_type': 'component_type',
                            'display_name': 'display_name',
                            'failure_messages': 'failure_messages',
                            'failures': 'failures',
                            'status': 'status',
                            }

    def __init__(self,
                 component_type=None,
                 display_name=None,
                 failure_messages=None,
                 failures=None,
                 status=None,
                ):
        """
        :type  component_type: :class:`str` or ``None``
        :param component_type: Component type
        :type  display_name: :class:`str` or ``None``
        :param display_name: Name of the pre/post-upgrade check
        :type  failure_messages: :class:`list` of :class:`str` or ``None``
        :param failure_messages: List of failure messages. This field is deprecated now. Please use
            failures instead.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  failures: :class:`list` of :class:`UpgradeCheckFailureMessage` or ``None``
        :param failures: List of failures
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  status: :class:`str` or ``None``
        :param status: Possible values are: 
            
            * :attr:`UpgradeCheck.STATUS_SUCCESS`
            * :attr:`UpgradeCheck.STATUS_FAILURE`
            * :attr:`UpgradeCheck.STATUS_WARNING`
            
             Status of pre/post-upgrade check
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.component_type = component_type
        self.display_name = display_name
        self.failure_messages = failure_messages
        self.failures = failures
        self.status = status
        VapiStruct.__init__(self)


UpgradeCheck._set_binding_type(type.StructType(
    'com.vmware.nsx.model.upgrade_check', {
        'component_type': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'failure_messages': type.OptionalType(type.ListType(type.StringType())),
        'failures': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'UpgradeCheckFailureMessage'))),
        'status': type.OptionalType(type.StringType()),
    },
    UpgradeCheck,
    False,
    None))



class UpgradeCheckCsvListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'file_name': 'file_name',
                            'results': 'results',
                            }

    def __init__(self,
                 file_name=None,
                 results=None,
                ):
        """
        :type  file_name: :class:`str` or ``None``
        :param file_name: File name set by HTTP server if API returns CSV result as a file.
        :type  results: :class:`list` of :class:`UpgradeCheckCsvRecord` or ``None``
        :param results: 
        """
        self.file_name = file_name
        self.results = results
        VapiStruct.__init__(self)


UpgradeCheckCsvListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.upgrade_check_csv_list_result', {
        'file_name': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'UpgradeCheckCsvRecord'))),
    },
    UpgradeCheckCsvListResult,
    False,
    None))



class UpgradeCheckCsvRecord(VapiStruct):
    """
    CSV record for a pre/post-upgrade check

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATUS_SUCCESS = "SUCCESS"
    """


    """
    STATUS_FAILURE = "FAILURE"
    """


    """
    STATUS_WARNING = "WARNING"
    """


    """



    _canonical_to_pep_names = {
                            'check_description': 'check_description',
                            'check_name': 'check_name',
                            'failure_messages': 'failure_messages',
                            'status': 'status',
                            'upgrade_unit_id': 'upgrade_unit_id',
                            'upgrade_unit_metadata': 'upgrade_unit_metadata',
                            'upgrade_unit_type': 'upgrade_unit_type',
                            }

    def __init__(self,
                 check_description=None,
                 check_name=None,
                 failure_messages=None,
                 status=None,
                 upgrade_unit_id=None,
                 upgrade_unit_metadata=None,
                 upgrade_unit_type=None,
                ):
        """
        :type  check_description: :class:`str` or ``None``
        :param check_description: Description of the pre/post-upgrade check
        :type  check_name: :class:`str` or ``None``
        :param check_name: Display name of the pre/post-upgrade check
        :type  failure_messages: :class:`str` or ``None``
        :param failure_messages: Space-separated list of failure messages
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  status: :class:`str` or ``None``
        :param status: Possible values are: 
            
            * :attr:`UpgradeCheckCsvRecord.STATUS_SUCCESS`
            * :attr:`UpgradeCheckCsvRecord.STATUS_FAILURE`
            * :attr:`UpgradeCheckCsvRecord.STATUS_WARNING`
            
             Status of the pre/post-upgrade check
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  upgrade_unit_id: :class:`str` or ``None``
        :param upgrade_unit_id: Identifier of the upgrade unit
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  upgrade_unit_metadata: :class:`str` or ``None``
        :param upgrade_unit_metadata: Meta-data of the upgrade-unit
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  upgrade_unit_type: :class:`str` or ``None``
        :param upgrade_unit_type: Component type of the upgrade unit
        """
        self.check_description = check_description
        self.check_name = check_name
        self.failure_messages = failure_messages
        self.status = status
        self.upgrade_unit_id = upgrade_unit_id
        self.upgrade_unit_metadata = upgrade_unit_metadata
        self.upgrade_unit_type = upgrade_unit_type
        VapiStruct.__init__(self)


UpgradeCheckCsvRecord._set_binding_type(type.StructType(
    'com.vmware.nsx.model.upgrade_check_csv_record', {
        'check_description': type.OptionalType(type.StringType()),
        'check_name': type.OptionalType(type.StringType()),
        'failure_messages': type.OptionalType(type.StringType()),
        'status': type.OptionalType(type.StringType()),
        'upgrade_unit_id': type.OptionalType(type.StringType()),
        'upgrade_unit_metadata': type.OptionalType(type.StringType()),
        'upgrade_unit_type': type.OptionalType(type.StringType()),
    },
    UpgradeCheckCsvRecord,
    False,
    None))



class UpgradeCheckFailure(VapiStruct):
    """
    Pre/post-upgrade check failure

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    ORIGIN_TYPE_COMPONENT = "COMPONENT"
    """


    """
    ORIGIN_TYPE_UPGRADE_UNIT = "UPGRADE_UNIT"
    """


    """
    TYPE_FAILURE = "FAILURE"
    """


    """
    TYPE_WARNING = "WARNING"
    """


    """



    _canonical_to_pep_names = {
                            'component_type': 'component_type',
                            'message': 'message',
                            'origin_id': 'origin_id',
                            'origin_name': 'origin_name',
                            'origin_type': 'origin_type',
                            'type': 'type',
                            }

    def __init__(self,
                 component_type=None,
                 message=None,
                 origin_id=None,
                 origin_name=None,
                 origin_type=None,
                 type=None,
                ):
        """
        :type  component_type: :class:`str` or ``None``
        :param component_type: Component type of the origin of failure
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  message: :class:`UpgradeCheckFailureMessage` or ``None``
        :param message: Pre/post-upgrade check failure message
        :type  origin_id: :class:`str` or ``None``
        :param origin_id: Unique id of origin of pre/post-upgrade check failure
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  origin_name: :class:`str` or ``None``
        :param origin_name: Name of origin of pre/post-upgrade check failure
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  origin_type: :class:`str` or ``None``
        :param origin_type: Possible values are: 
            
            * :attr:`UpgradeCheckFailure.ORIGIN_TYPE_COMPONENT`
            * :attr:`UpgradeCheckFailure.ORIGIN_TYPE_UPGRADE_UNIT`
            
             Type of origin of pre/post-upgrade check failure
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  type: :class:`str` or ``None``
        :param type: Possible values are: 
            
            * :attr:`UpgradeCheckFailure.TYPE_FAILURE`
            * :attr:`UpgradeCheckFailure.TYPE_WARNING`
            
             Type of the pre/post-upgrade check failure
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.component_type = component_type
        self.message = message
        self.origin_id = origin_id
        self.origin_name = origin_name
        self.origin_type = origin_type
        self.type = type
        VapiStruct.__init__(self)


UpgradeCheckFailure._set_binding_type(type.StructType(
    'com.vmware.nsx.model.upgrade_check_failure', {
        'component_type': type.OptionalType(type.StringType()),
        'message': type.OptionalType(type.ReferenceType(__name__, 'UpgradeCheckFailureMessage')),
        'origin_id': type.OptionalType(type.StringType()),
        'origin_name': type.OptionalType(type.StringType()),
        'origin_type': type.OptionalType(type.StringType()),
        'type': type.OptionalType(type.StringType()),
    },
    UpgradeCheckFailure,
    False,
    None))



class UpgradeCheckFailureListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`UpgradeCheckFailure` or ``None``
        :param results: Collection of pre/post-upgrade check failures
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


UpgradeCheckFailureListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.upgrade_check_failure_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'UpgradeCheckFailure'))),
    },
    UpgradeCheckFailureListResult,
    False,
    None))



class UpgradeCheckFailureMessage(VapiStruct):
    """
    Pre/post-upgrade check failure message

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'error_code': 'error_code',
                            'message': 'message',
                            }

    def __init__(self,
                 error_code=None,
                 message=None,
                ):
        """
        :type  error_code: :class:`long` or ``None``
        :param error_code: Error code for the error/warning format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  message: :class:`str` or ``None``
        :param message: Error/warning message
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.error_code = error_code
        self.message = message
        VapiStruct.__init__(self)


UpgradeCheckFailureMessage._set_binding_type(type.StructType(
    'com.vmware.nsx.model.upgrade_check_failure_message', {
        'error_code': type.OptionalType(type.IntegerType()),
        'message': type.OptionalType(type.StringType()),
    },
    UpgradeCheckFailureMessage,
    False,
    None))



class UpgradeCheckInfo(VapiStruct):
    """
    Meta-data of a pre/post-upgrade check

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'component_type': 'component_type',
                            'description': 'description',
                            'name': 'name',
                            }

    def __init__(self,
                 component_type=None,
                 description=None,
                 name=None,
                ):
        """
        :type  component_type: :class:`str` or ``None``
        :param component_type: Component type of the pre/post-upgrade check
        :type  description: :class:`str` or ``None``
        :param description: Description of the pre/post-upgrade check
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  name: :class:`str` or ``None``
        :param name: Display name of the pre/post-upgrade check
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.component_type = component_type
        self.description = description
        self.name = name
        VapiStruct.__init__(self)


UpgradeCheckInfo._set_binding_type(type.StructType(
    'com.vmware.nsx.model.upgrade_check_info', {
        'component_type': type.OptionalType(type.StringType()),
        'description': type.OptionalType(type.StringType()),
        'name': type.OptionalType(type.StringType()),
    },
    UpgradeCheckInfo,
    False,
    None))



class UpgradeCheckListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'checks': 'checks',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 checks=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  checks: :class:`list` of :class:`UpgradeCheck` or ``None``
        :param checks: Paged Collection of pre/post-upgrade checks
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.checks = checks
        VapiStruct.__init__(self)


UpgradeCheckListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.upgrade_check_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'checks': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'UpgradeCheck'))),
    },
    UpgradeCheckListResult,
    False,
    None))



class UpgradeCheckListResults(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'checks_with_warnings': 'checks_with_warnings',
                            'failed_checks': 'failed_checks',
                            'successful_checks': 'successful_checks',
                            }

    def __init__(self,
                 checks_with_warnings=None,
                 failed_checks=None,
                 successful_checks=None,
                ):
        """
        :type  checks_with_warnings: :class:`UpgradeCheckListResult` or ``None``
        :param checks_with_warnings: 
        :type  failed_checks: :class:`UpgradeCheckListResult` or ``None``
        :param failed_checks: 
        :type  successful_checks: :class:`UpgradeCheckListResult` or ``None``
        :param successful_checks: 
        """
        self.checks_with_warnings = checks_with_warnings
        self.failed_checks = failed_checks
        self.successful_checks = successful_checks
        VapiStruct.__init__(self)


UpgradeCheckListResults._set_binding_type(type.StructType(
    'com.vmware.nsx.model.upgrade_check_list_results', {
        'checks_with_warnings': type.OptionalType(type.ReferenceType(__name__, 'UpgradeCheckListResult')),
        'failed_checks': type.OptionalType(type.ReferenceType(__name__, 'UpgradeCheckListResult')),
        'successful_checks': type.OptionalType(type.ReferenceType(__name__, 'UpgradeCheckListResult')),
    },
    UpgradeCheckListResults,
    False,
    None))



class UpgradeChecksExecutionStatus(VapiStruct):
    """
    Execution status of pre/post-upgrade checks

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATUS_NOT_STARTED = "NOT_STARTED"
    """


    """
    STATUS_IN_PROGRESS = "IN_PROGRESS"
    """


    """
    STATUS_ABORTING = "ABORTING"
    """


    """
    STATUS_ABORTED = "ABORTED"
    """


    """
    STATUS_COMPLETED = "COMPLETED"
    """


    """



    _canonical_to_pep_names = {
                            'details': 'details',
                            'end_time': 'end_time',
                            'failure_count': 'failure_count',
                            'node_with_issues_count': 'node_with_issues_count',
                            'start_time': 'start_time',
                            'status': 'status',
                            }

    def __init__(self,
                 details=None,
                 end_time=None,
                 failure_count=None,
                 node_with_issues_count=None,
                 start_time=None,
                 status=None,
                ):
        """
        :type  details: :class:`str` or ``None``
        :param details: Details about current execution of pre/post-upgrade checks
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  end_time: :class:`long` or ``None``
        :param end_time: Time (in milliseconds since epoch) when the execution of
            pre/post-upgrade checks completed format: int64
        :type  failure_count: :class:`long` or ``None``
        :param failure_count: Total count of generated failures or warnings in last execution of
            pre/post-upgrade checks format: int32
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  node_with_issues_count: :class:`long` or ``None``
        :param node_with_issues_count: Number of nodes which generated failures or warnings in last
            execution of pre/post-upgrade checks format: int32
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  start_time: :class:`long` or ``None``
        :param start_time: Time (in milliseconds since epoch) when the execution of
            pre/post-upgrade checks started format: int64
        :type  status: :class:`str` or ``None``
        :param status: Possible values are: 
            
            * :attr:`UpgradeChecksExecutionStatus.STATUS_NOT_STARTED`
            * :attr:`UpgradeChecksExecutionStatus.STATUS_IN_PROGRESS`
            * :attr:`UpgradeChecksExecutionStatus.STATUS_ABORTING`
            * :attr:`UpgradeChecksExecutionStatus.STATUS_ABORTED`
            * :attr:`UpgradeChecksExecutionStatus.STATUS_COMPLETED`
            
             Status of execution of pre/post-upgrade checks
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.details = details
        self.end_time = end_time
        self.failure_count = failure_count
        self.node_with_issues_count = node_with_issues_count
        self.start_time = start_time
        self.status = status
        VapiStruct.__init__(self)


UpgradeChecksExecutionStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.upgrade_checks_execution_status', {
        'details': type.OptionalType(type.StringType()),
        'end_time': type.OptionalType(type.IntegerType()),
        'failure_count': type.OptionalType(type.IntegerType()),
        'node_with_issues_count': type.OptionalType(type.IntegerType()),
        'start_time': type.OptionalType(type.IntegerType()),
        'status': type.OptionalType(type.StringType()),
    },
    UpgradeChecksExecutionStatus,
    False,
    None))



class UpgradeHistory(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    UPGRADE_STATUS_STARTED = "STARTED"
    """


    """
    UPGRADE_STATUS_SUCCESS = "SUCCESS"
    """


    """
    UPGRADE_STATUS_FAILED = "FAILED"
    """


    """



    _canonical_to_pep_names = {
                            'initial_version': 'initial_version',
                            'target_version': 'target_version',
                            'timestamp': 'timestamp',
                            'upgrade_status': 'upgrade_status',
                            }

    def __init__(self,
                 initial_version=None,
                 target_version=None,
                 timestamp=None,
                 upgrade_status=None,
                ):
        """
        :type  initial_version: :class:`str` or ``None``
        :param initial_version: Version before the upgrade started
        :type  target_version: :class:`str` or ``None``
        :param target_version: Version being upgraded to
        :type  timestamp: :class:`long` or ``None``
        :param timestamp: Timestamp (in milliseconds since epoch) when the upgrade was
            performed format: int64
        :type  upgrade_status: :class:`str` or ``None``
        :param upgrade_status: Possible values are: 
            
            * :attr:`UpgradeHistory.UPGRADE_STATUS_STARTED`
            * :attr:`UpgradeHistory.UPGRADE_STATUS_SUCCESS`
            * :attr:`UpgradeHistory.UPGRADE_STATUS_FAILED`
            
             Status of the upgrade
        """
        self.initial_version = initial_version
        self.target_version = target_version
        self.timestamp = timestamp
        self.upgrade_status = upgrade_status
        VapiStruct.__init__(self)


UpgradeHistory._set_binding_type(type.StructType(
    'com.vmware.nsx.model.upgrade_history', {
        'initial_version': type.OptionalType(type.StringType()),
        'target_version': type.OptionalType(type.StringType()),
        'timestamp': type.OptionalType(type.IntegerType()),
        'upgrade_status': type.OptionalType(type.StringType()),
    },
    UpgradeHistory,
    False,
    None))



class UpgradeHistoryList(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`UpgradeHistory` or ``None``
        :param results: Upgrade history list
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


UpgradeHistoryList._set_binding_type(type.StructType(
    'com.vmware.nsx.model.upgrade_history_list', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'UpgradeHistory'))),
    },
    UpgradeHistoryList,
    False,
    None))



class UpgradePlanSettings(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'parallel': 'parallel',
                            'pause_after_each_group': 'pause_after_each_group',
                            'pause_on_error': 'pause_on_error',
                            }

    def __init__(self,
                 parallel=None,
                 pause_after_each_group=None,
                 pause_on_error=None,
                ):
        """
        :type  parallel: :class:`bool` or ``None``
        :param parallel: Upgrade Method to specify whether the upgrade is to be performed
            serially or in parallel
        :type  pause_after_each_group: :class:`bool` or ``None``
        :param pause_after_each_group: Flag to indicate whether to pause the upgrade after upgrade of each
            group is completed
        :type  pause_on_error: :class:`bool` or ``None``
        :param pause_on_error: Flag to indicate whether to pause the upgrade plan execution when
            an error occurs
        """
        self.parallel = parallel
        self.pause_after_each_group = pause_after_each_group
        self.pause_on_error = pause_on_error
        VapiStruct.__init__(self)


UpgradePlanSettings._set_binding_type(type.StructType(
    'com.vmware.nsx.model.upgrade_plan_settings', {
        'parallel': type.OptionalType(type.BooleanType()),
        'pause_after_each_group': type.OptionalType(type.BooleanType()),
        'pause_on_error': type.OptionalType(type.BooleanType()),
    },
    UpgradePlanSettings,
    False,
    None))



class UpgradeProgressStatus(VapiStruct):
    """
    Upgrade progress status

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'last_upgrade_step_status': 'last_upgrade_step_status',
                            'upgrade_bundle_present': 'upgrade_bundle_present',
                            'upgrade_metadata': 'upgrade_metadata',
                            }

    def __init__(self,
                 last_upgrade_step_status=None,
                 upgrade_bundle_present=None,
                 upgrade_metadata=None,
                ):
        """
        :type  last_upgrade_step_status: :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param last_upgrade_step_status: Status of last upgrade step
        :type  upgrade_bundle_present: :class:`bool` or ``None``
        :param upgrade_bundle_present: True if upgrade bundle is present
        :type  upgrade_metadata: :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param upgrade_metadata: Meta info of upgrade
        """
        self.last_upgrade_step_status = last_upgrade_step_status
        self.upgrade_bundle_present = upgrade_bundle_present
        self.upgrade_metadata = upgrade_metadata
        VapiStruct.__init__(self)


UpgradeProgressStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.upgrade_progress_status', {
        'last_upgrade_step_status': type.OptionalType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct)),
        'upgrade_bundle_present': type.OptionalType(type.BooleanType()),
        'upgrade_metadata': type.OptionalType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct)),
    },
    UpgradeProgressStatus,
    False,
    None))



class UpgradeStatus(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    OVERALL_UPGRADE_STATUS_SUCCESS = "SUCCESS"
    """


    """
    OVERALL_UPGRADE_STATUS_FAILED = "FAILED"
    """


    """
    OVERALL_UPGRADE_STATUS_IN_PROGRESS = "IN_PROGRESS"
    """


    """
    OVERALL_UPGRADE_STATUS_NOT_STARTED = "NOT_STARTED"
    """


    """
    OVERALL_UPGRADE_STATUS_PAUSING = "PAUSING"
    """


    """
    OVERALL_UPGRADE_STATUS_PAUSED = "PAUSED"
    """


    """



    _canonical_to_pep_names = {
                            'ccp_status': 'ccp_status',
                            'component_status': 'component_status',
                            'edge_status': 'edge_status',
                            'host_status': 'host_status',
                            'overall_upgrade_status': 'overall_upgrade_status',
                            }

    def __init__(self,
                 ccp_status=None,
                 component_status=None,
                 edge_status=None,
                 host_status=None,
                 overall_upgrade_status=None,
                ):
        """
        :type  ccp_status: :class:`CCPUpgradeStatus` or ``None``
        :param ccp_status: CCP upgrade status
        :type  component_status: :class:`list` of :class:`ComponentUpgradeStatus` or ``None``
        :param component_status: List of component statuses
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  edge_status: :class:`EdgeUpgradeStatus` or ``None``
        :param edge_status: Edge upgrade status
        :type  host_status: :class:`HostUpgradeStatus` or ``None``
        :param host_status: Host upgrade status
        :type  overall_upgrade_status: :class:`str` or ``None``
        :param overall_upgrade_status: Possible values are: 
            
            * :attr:`UpgradeStatus.OVERALL_UPGRADE_STATUS_SUCCESS`
            * :attr:`UpgradeStatus.OVERALL_UPGRADE_STATUS_FAILED`
            * :attr:`UpgradeStatus.OVERALL_UPGRADE_STATUS_IN_PROGRESS`
            * :attr:`UpgradeStatus.OVERALL_UPGRADE_STATUS_NOT_STARTED`
            * :attr:`UpgradeStatus.OVERALL_UPGRADE_STATUS_PAUSING`
            * :attr:`UpgradeStatus.OVERALL_UPGRADE_STATUS_PAUSED`
            
             Status of upgrade
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.ccp_status = ccp_status
        self.component_status = component_status
        self.edge_status = edge_status
        self.host_status = host_status
        self.overall_upgrade_status = overall_upgrade_status
        VapiStruct.__init__(self)


UpgradeStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.upgrade_status', {
        'ccp_status': type.OptionalType(type.ReferenceType(__name__, 'CCPUpgradeStatus')),
        'component_status': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ComponentUpgradeStatus'))),
        'edge_status': type.OptionalType(type.ReferenceType(__name__, 'EdgeUpgradeStatus')),
        'host_status': type.OptionalType(type.ReferenceType(__name__, 'HostUpgradeStatus')),
        'overall_upgrade_status': type.OptionalType(type.StringType()),
    },
    UpgradeStatus,
    False,
    None))



class UpgradeStatusSummary(VapiStruct):
    """
    Upgrade status summry

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'upgrade_bundle_present': 'upgrade_bundle_present',
                            'upgrade_metadata': 'upgrade_metadata',
                            'upgrade_steps': 'upgrade_steps',
                            }

    def __init__(self,
                 upgrade_bundle_present=None,
                 upgrade_metadata=None,
                 upgrade_steps=None,
                ):
        """
        :type  upgrade_bundle_present: :class:`bool` or ``None``
        :param upgrade_bundle_present: True if upgrade bundle is present
        :type  upgrade_metadata: :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param upgrade_metadata: Meta info of upgrade
        :type  upgrade_steps: :class:`list` of :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param upgrade_steps: List of all upgrade steps performed
        """
        self.upgrade_bundle_present = upgrade_bundle_present
        self.upgrade_metadata = upgrade_metadata
        self.upgrade_steps = upgrade_steps
        VapiStruct.__init__(self)


UpgradeStatusSummary._set_binding_type(type.StructType(
    'com.vmware.nsx.model.upgrade_status_summary', {
        'upgrade_bundle_present': type.OptionalType(type.BooleanType()),
        'upgrade_metadata': type.OptionalType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct)),
        'upgrade_steps': type.OptionalType(type.ListType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct))),
    },
    UpgradeStatusSummary,
    False,
    None))



class UpgradeSummary(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    UPGRADE_STATUS_SUCCESS = "SUCCESS"
    """


    """
    UPGRADE_STATUS_FAILED = "FAILED"
    """


    """
    UPGRADE_STATUS_IN_PROGRESS = "IN_PROGRESS"
    """


    """
    UPGRADE_STATUS_NOT_STARTED = "NOT_STARTED"
    """


    """
    UPGRADE_STATUS_PAUSING = "PAUSING"
    """


    """
    UPGRADE_STATUS_PAUSED = "PAUSED"
    """


    """



    _canonical_to_pep_names = {
                            'component_target_versions': 'component_target_versions',
                            'system_version': 'system_version',
                            'target_version': 'target_version',
                            'upgrade_bundle_file_name': 'upgrade_bundle_file_name',
                            'upgrade_coordinator_updated': 'upgrade_coordinator_updated',
                            'upgrade_coordinator_version': 'upgrade_coordinator_version',
                            'upgrade_status': 'upgrade_status',
                            }

    def __init__(self,
                 component_target_versions=None,
                 system_version=None,
                 target_version=None,
                 upgrade_bundle_file_name=None,
                 upgrade_coordinator_updated=None,
                 upgrade_coordinator_version=None,
                 upgrade_status=None,
                ):
        """
        :type  component_target_versions: :class:`list` of :class:`ComponentTargetVersion` or ``None``
        :param component_target_versions: 
        :type  system_version: :class:`str` or ``None``
        :param system_version: Current system version
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  target_version: :class:`str` or ``None``
        :param target_version: Target system version
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  upgrade_bundle_file_name: :class:`str` or ``None``
        :param upgrade_bundle_file_name: Name of the last successfully uploaded upgrade bundle file
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  upgrade_coordinator_updated: :class:`bool` or ``None``
        :param upgrade_coordinator_updated: Has upgrade coordinator been updated after upload of upgrade bundle
            file
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  upgrade_coordinator_version: :class:`str` or ``None``
        :param upgrade_coordinator_version: Current version of upgrade coordinator
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  upgrade_status: :class:`str` or ``None``
        :param upgrade_status: Possible values are: 
            
            * :attr:`UpgradeSummary.UPGRADE_STATUS_SUCCESS`
            * :attr:`UpgradeSummary.UPGRADE_STATUS_FAILED`
            * :attr:`UpgradeSummary.UPGRADE_STATUS_IN_PROGRESS`
            * :attr:`UpgradeSummary.UPGRADE_STATUS_NOT_STARTED`
            * :attr:`UpgradeSummary.UPGRADE_STATUS_PAUSING`
            * :attr:`UpgradeSummary.UPGRADE_STATUS_PAUSED`
            
             Status of upgrade
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.component_target_versions = component_target_versions
        self.system_version = system_version
        self.target_version = target_version
        self.upgrade_bundle_file_name = upgrade_bundle_file_name
        self.upgrade_coordinator_updated = upgrade_coordinator_updated
        self.upgrade_coordinator_version = upgrade_coordinator_version
        self.upgrade_status = upgrade_status
        VapiStruct.__init__(self)


UpgradeSummary._set_binding_type(type.StructType(
    'com.vmware.nsx.model.upgrade_summary', {
        'component_target_versions': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ComponentTargetVersion'))),
        'system_version': type.OptionalType(type.StringType()),
        'target_version': type.OptionalType(type.StringType()),
        'upgrade_bundle_file_name': type.OptionalType(type.StringType()),
        'upgrade_coordinator_updated': type.OptionalType(type.BooleanType()),
        'upgrade_coordinator_version': type.OptionalType(type.StringType()),
        'upgrade_status': type.OptionalType(type.StringType()),
    },
    UpgradeSummary,
    False,
    None))



class UpgradeTaskProperties(VapiStruct):
    """
    Task properties

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'bundle_name': 'bundle_name',
                            'parameters': 'parameters',
                            'step': 'step',
                            }

    def __init__(self,
                 bundle_name=None,
                 parameters=None,
                 step=None,
                ):
        """
        :type  bundle_name: :class:`str` or ``None``
        :param bundle_name: Name of Bundle
        :type  parameters: :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param parameters: Bundle arguments
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  step: :class:`str` or ``None``
        :param step: Step name
        """
        self.bundle_name = bundle_name
        self.parameters = parameters
        self.step = step
        VapiStruct.__init__(self)


UpgradeTaskProperties._set_binding_type(type.StructType(
    'com.vmware.nsx.model.upgrade_task_properties', {
        'bundle_name': type.OptionalType(type.StringType()),
        'parameters': type.OptionalType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct)),
        'step': type.OptionalType(type.StringType()),
    },
    UpgradeTaskProperties,
    False,
    None))



class UpgradeTopology(VapiStruct):
    """
    Recommended topology for migrating NVDS to VDS

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'topology': 'topology',
                            }

    def __init__(self,
                 topology=None,
                ):
        """
        :type  topology: :class:`list` of :class:`NvdsUpgradeTopology` or ``None``
        :param topology: All resultant VDS mapping for a NVDS after the migration
        """
        self.topology = topology
        VapiStruct.__init__(self)


UpgradeTopology._set_binding_type(type.StructType(
    'com.vmware.nsx.model.upgrade_topology', {
        'topology': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NvdsUpgradeTopology'))),
    },
    UpgradeTopology,
    False,
    None))



class UpgradeUnit(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'current_version': 'current_version',
                            'display_name': 'display_name',
                            'group': 'group',
                            'id': 'id',
                            'metadata': 'metadata',
                            'type': 'type',
                            'warnings': 'warnings',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 current_version=None,
                 display_name=None,
                 group=None,
                 id=None,
                 metadata=None,
                 type=None,
                 warnings=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  current_version: :class:`str` or ``None``
        :param current_version: This is component version e.g. if upgrade unit is of type edge,
            then this is edge version.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  display_name: :class:`str` or ``None``
        :param display_name: Name of the upgrade unit
        :type  group: :class:`UpgradeUnitGroupInfo` or ``None``
        :param group: Info of the group to which this upgrade unit belongs
        :type  id: :class:`str` or ``None``
        :param id: Identifier of the upgrade unit
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  metadata: :class:`list` of :class:`KeyValuePair` or ``None``
        :param metadata: Metadata about upgrade unit
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  type: :class:`str` or ``None``
        :param type: Upgrade unit type
        :type  warnings: :class:`list` of :class:`str` or ``None``
        :param warnings: List of warnings indicating issues with the upgrade unit that may
            result in upgrade failure
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.current_version = current_version
        self.display_name = display_name
        self.group = group
        self.id = id
        self.metadata = metadata
        self.type = type
        self.warnings = warnings
        VapiStruct.__init__(self)


UpgradeUnit._set_binding_type(type.StructType(
    'com.vmware.nsx.model.upgrade_unit', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'current_version': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'group': type.OptionalType(type.ReferenceType(__name__, 'UpgradeUnitGroupInfo')),
        'id': type.OptionalType(type.StringType()),
        'metadata': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'KeyValuePair'))),
        'type': type.OptionalType(type.StringType()),
        'warnings': type.OptionalType(type.ListType(type.StringType())),
    },
    UpgradeUnit,
    False,
    None))



class UpgradeUnitAggregateInfo(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATUS_SUCCESS = "SUCCESS"
    """


    """
    STATUS_FAILED = "FAILED"
    """


    """
    STATUS_IN_PROGRESS = "IN_PROGRESS"
    """


    """
    STATUS_NOT_STARTED = "NOT_STARTED"
    """


    """
    STATUS_PAUSING = "PAUSING"
    """


    """
    STATUS_PAUSED = "PAUSED"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'current_version': 'current_version',
                            'display_name': 'display_name',
                            'errors': 'errors',
                            'group': 'group',
                            'id': 'id',
                            'metadata': 'metadata',
                            'percent_complete': 'percent_complete',
                            'post_upgrade_checks': 'post_upgrade_checks',
                            'pre_upgrade_checks': 'pre_upgrade_checks',
                            'status': 'status',
                            'type': 'type',
                            'warnings': 'warnings',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 current_version=None,
                 display_name=None,
                 errors=None,
                 group=None,
                 id=None,
                 metadata=None,
                 percent_complete=None,
                 post_upgrade_checks=None,
                 pre_upgrade_checks=None,
                 status=None,
                 type=None,
                 warnings=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  current_version: :class:`str` or ``None``
        :param current_version: This is component version e.g. if upgrade unit is of type edge,
            then this is edge version.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  display_name: :class:`str` or ``None``
        :param display_name: Name of the upgrade unit
        :type  errors: :class:`list` of :class:`str` or ``None``
        :param errors: List of errors occurred during upgrade of this upgrade unit
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  group: :class:`UpgradeUnitGroupInfo` or ``None``
        :param group: Info of the group to which this upgrade unit belongs
        :type  id: :class:`str` or ``None``
        :param id: Identifier of the upgrade unit
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  metadata: :class:`list` of :class:`KeyValuePair` or ``None``
        :param metadata: Metadata about upgrade unit
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  percent_complete: :class:`float` or ``None``
        :param percent_complete: Indicator of upgrade progress in percentage
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  post_upgrade_checks: :class:`UpgradeCheckListResults` or ``None``
        :param post_upgrade_checks: 
        :type  pre_upgrade_checks: :class:`UpgradeCheckListResults` or ``None``
        :param pre_upgrade_checks: 
        :type  status: :class:`str` or ``None``
        :param status: Possible values are: 
            
            * :attr:`UpgradeUnitAggregateInfo.STATUS_SUCCESS`
            * :attr:`UpgradeUnitAggregateInfo.STATUS_FAILED`
            * :attr:`UpgradeUnitAggregateInfo.STATUS_IN_PROGRESS`
            * :attr:`UpgradeUnitAggregateInfo.STATUS_NOT_STARTED`
            * :attr:`UpgradeUnitAggregateInfo.STATUS_PAUSING`
            * :attr:`UpgradeUnitAggregateInfo.STATUS_PAUSED`
            
             Status of upgrade unit
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  type: :class:`str` or ``None``
        :param type: Upgrade unit type
        :type  warnings: :class:`list` of :class:`str` or ``None``
        :param warnings: List of warnings indicating issues with the upgrade unit that may
            result in upgrade failure
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.current_version = current_version
        self.display_name = display_name
        self.errors = errors
        self.group = group
        self.id = id
        self.metadata = metadata
        self.percent_complete = percent_complete
        self.post_upgrade_checks = post_upgrade_checks
        self.pre_upgrade_checks = pre_upgrade_checks
        self.status = status
        self.type = type
        self.warnings = warnings
        VapiStruct.__init__(self)


UpgradeUnitAggregateInfo._set_binding_type(type.StructType(
    'com.vmware.nsx.model.upgrade_unit_aggregate_info', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'current_version': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'errors': type.OptionalType(type.ListType(type.StringType())),
        'group': type.OptionalType(type.ReferenceType(__name__, 'UpgradeUnitGroupInfo')),
        'id': type.OptionalType(type.StringType()),
        'metadata': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'KeyValuePair'))),
        'percent_complete': type.OptionalType(type.DoubleType()),
        'post_upgrade_checks': type.OptionalType(type.ReferenceType(__name__, 'UpgradeCheckListResults')),
        'pre_upgrade_checks': type.OptionalType(type.ReferenceType(__name__, 'UpgradeCheckListResults')),
        'status': type.OptionalType(type.StringType()),
        'type': type.OptionalType(type.StringType()),
        'warnings': type.OptionalType(type.ListType(type.StringType())),
    },
    UpgradeUnitAggregateInfo,
    False,
    None))



class UpgradeUnitAggregateInfoListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`UpgradeUnitAggregateInfo` or ``None``
        :param results: Paged collection of UpgradeUnit AggregateInfo
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


UpgradeUnitAggregateInfoListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.upgrade_unit_aggregate_info_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'UpgradeUnitAggregateInfo'))),
    },
    UpgradeUnitAggregateInfoListResult,
    False,
    None))



class UpgradeUnitGroup(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'enabled': 'enabled',
                            'extended_configuration': 'extended_configuration',
                            'parallel': 'parallel',
                            'type': 'type',
                            'upgrade_unit_count': 'upgrade_unit_count',
                            'upgrade_units': 'upgrade_units',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 enabled=None,
                 extended_configuration=None,
                 parallel=None,
                 type=None,
                 upgrade_unit_count=None,
                 upgrade_units=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  enabled: :class:`bool` or ``None``
        :param enabled: Flag to indicate whether upgrade of this group is enabled or not
        :type  extended_configuration: :class:`list` of :class:`KeyValuePair` or ``None``
        :param extended_configuration: Extended configuration for the group
        :type  parallel: :class:`bool` or ``None``
        :param parallel: Upgrade method to specify whether the upgrade is to be performed in
            parallel or serially
        :type  type: :class:`str` or ``None``
        :param type: Component type
        :type  upgrade_unit_count: :class:`long` or ``None``
        :param upgrade_unit_count: Number of upgrade units in the group format: int32
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  upgrade_units: :class:`list` of :class:`UpgradeUnit` or ``None``
        :param upgrade_units: List of upgrade units in the group
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.enabled = enabled
        self.extended_configuration = extended_configuration
        self.parallel = parallel
        self.type = type
        self.upgrade_unit_count = upgrade_unit_count
        self.upgrade_units = upgrade_units
        VapiStruct.__init__(self)


UpgradeUnitGroup._set_binding_type(type.StructType(
    'com.vmware.nsx.model.upgrade_unit_group', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'enabled': type.OptionalType(type.BooleanType()),
        'extended_configuration': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'KeyValuePair'))),
        'parallel': type.OptionalType(type.BooleanType()),
        'type': type.OptionalType(type.StringType()),
        'upgrade_unit_count': type.OptionalType(type.IntegerType()),
        'upgrade_units': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'UpgradeUnit'))),
    },
    UpgradeUnitGroup,
    False,
    None))



class UpgradeUnitGroupAggregateInfo(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATUS_SUCCESS = "SUCCESS"
    """


    """
    STATUS_FAILED = "FAILED"
    """


    """
    STATUS_IN_PROGRESS = "IN_PROGRESS"
    """


    """
    STATUS_NOT_STARTED = "NOT_STARTED"
    """


    """
    STATUS_PAUSING = "PAUSING"
    """


    """
    STATUS_PAUSED = "PAUSED"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'enabled': 'enabled',
                            'extended_configuration': 'extended_configuration',
                            'failed_count': 'failed_count',
                            'parallel': 'parallel',
                            'percent_complete': 'percent_complete',
                            'post_upgrade_status': 'post_upgrade_status',
                            'status': 'status',
                            'type': 'type',
                            'upgrade_unit_count': 'upgrade_unit_count',
                            'upgrade_units': 'upgrade_units',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 enabled=None,
                 extended_configuration=None,
                 failed_count=None,
                 parallel=None,
                 percent_complete=None,
                 post_upgrade_status=None,
                 status=None,
                 type=None,
                 upgrade_unit_count=None,
                 upgrade_units=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  enabled: :class:`bool` or ``None``
        :param enabled: Flag to indicate whether upgrade of this group is enabled or not
        :type  extended_configuration: :class:`list` of :class:`KeyValuePair` or ``None``
        :param extended_configuration: Extended configuration for the group
        :type  failed_count: :class:`long` or ``None``
        :param failed_count: Number of nodes in the upgrade unit group that failed upgrade
            format: int32
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  parallel: :class:`bool` or ``None``
        :param parallel: Upgrade method to specify whether the upgrade is to be performed in
            parallel or serially
        :type  percent_complete: :class:`float` or ``None``
        :param percent_complete: Indicator of upgrade progress in percentage
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  post_upgrade_status: :class:`UpgradeChecksExecutionStatus` or ``None``
        :param post_upgrade_status: Post-upgrade status of group
        :type  status: :class:`str` or ``None``
        :param status: Possible values are: 
            
            * :attr:`UpgradeUnitGroupAggregateInfo.STATUS_SUCCESS`
            * :attr:`UpgradeUnitGroupAggregateInfo.STATUS_FAILED`
            * :attr:`UpgradeUnitGroupAggregateInfo.STATUS_IN_PROGRESS`
            * :attr:`UpgradeUnitGroupAggregateInfo.STATUS_NOT_STARTED`
            * :attr:`UpgradeUnitGroupAggregateInfo.STATUS_PAUSING`
            * :attr:`UpgradeUnitGroupAggregateInfo.STATUS_PAUSED`
            
             Upgrade status of upgrade unit group
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  type: :class:`str` or ``None``
        :param type: Component type
        :type  upgrade_unit_count: :class:`long` or ``None``
        :param upgrade_unit_count: Number of upgrade units in the group format: int32
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  upgrade_units: :class:`list` of :class:`UpgradeUnit` or ``None``
        :param upgrade_units: List of upgrade units in the group
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.enabled = enabled
        self.extended_configuration = extended_configuration
        self.failed_count = failed_count
        self.parallel = parallel
        self.percent_complete = percent_complete
        self.post_upgrade_status = post_upgrade_status
        self.status = status
        self.type = type
        self.upgrade_unit_count = upgrade_unit_count
        self.upgrade_units = upgrade_units
        VapiStruct.__init__(self)


UpgradeUnitGroupAggregateInfo._set_binding_type(type.StructType(
    'com.vmware.nsx.model.upgrade_unit_group_aggregate_info', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'enabled': type.OptionalType(type.BooleanType()),
        'extended_configuration': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'KeyValuePair'))),
        'failed_count': type.OptionalType(type.IntegerType()),
        'parallel': type.OptionalType(type.BooleanType()),
        'percent_complete': type.OptionalType(type.DoubleType()),
        'post_upgrade_status': type.OptionalType(type.ReferenceType(__name__, 'UpgradeChecksExecutionStatus')),
        'status': type.OptionalType(type.StringType()),
        'type': type.OptionalType(type.StringType()),
        'upgrade_unit_count': type.OptionalType(type.IntegerType()),
        'upgrade_units': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'UpgradeUnit'))),
    },
    UpgradeUnitGroupAggregateInfo,
    False,
    None))



class UpgradeUnitGroupAggregateInfoListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`UpgradeUnitGroupAggregateInfo` or ``None``
        :param results: Paged collection of upgrade status for upgrade unit groups
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


UpgradeUnitGroupAggregateInfoListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.upgrade_unit_group_aggregate_info_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'UpgradeUnitGroupAggregateInfo'))),
    },
    UpgradeUnitGroupAggregateInfoListResult,
    False,
    None))



class UpgradeUnitGroupInfo(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'display_name': 'display_name',
                            'id': 'id',
                            }

    def __init__(self,
                 display_name=None,
                 id=None,
                ):
        """
        :type  display_name: :class:`str` or ``None``
        :param display_name: Name of the group
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  id: :class:`str` or ``None``
        :param id: Identifier of group
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.display_name = display_name
        self.id = id
        VapiStruct.__init__(self)


UpgradeUnitGroupInfo._set_binding_type(type.StructType(
    'com.vmware.nsx.model.upgrade_unit_group_info', {
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
    },
    UpgradeUnitGroupInfo,
    False,
    None))



class UpgradeUnitGroupListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`UpgradeUnitGroup` or ``None``
        :param results: Paged Collection of Upgrade unit groups
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


UpgradeUnitGroupListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.upgrade_unit_group_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'UpgradeUnitGroup'))),
    },
    UpgradeUnitGroupListResult,
    False,
    None))



class UpgradeUnitGroupStatus(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATUS_SUCCESS = "SUCCESS"
    """


    """
    STATUS_FAILED = "FAILED"
    """


    """
    STATUS_IN_PROGRESS = "IN_PROGRESS"
    """


    """
    STATUS_NOT_STARTED = "NOT_STARTED"
    """


    """
    STATUS_PAUSING = "PAUSING"
    """


    """
    STATUS_PAUSED = "PAUSED"
    """


    """



    _canonical_to_pep_names = {
                            'failed_count': 'failed_count',
                            'group_id': 'group_id',
                            'group_name': 'group_name',
                            'percent_complete': 'percent_complete',
                            'status': 'status',
                            'upgrade_unit_count': 'upgrade_unit_count',
                            }

    def __init__(self,
                 failed_count=None,
                 group_id=None,
                 group_name=None,
                 percent_complete=None,
                 status=None,
                 upgrade_unit_count=None,
                ):
        """
        :type  failed_count: :class:`long` or ``None``
        :param failed_count: Number of nodes in the upgrade unit group that failed upgrade
            format: int32
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  group_id: :class:`str` or ``None``
        :param group_id: Identifier for upgrade unit group
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  group_name: :class:`str` or ``None``
        :param group_name: Name of the upgrade unit group
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  percent_complete: :class:`float` or ``None``
        :param percent_complete: Indicator of upgrade progress in percentage
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  status: :class:`str` or ``None``
        :param status: Possible values are: 
            
            * :attr:`UpgradeUnitGroupStatus.STATUS_SUCCESS`
            * :attr:`UpgradeUnitGroupStatus.STATUS_FAILED`
            * :attr:`UpgradeUnitGroupStatus.STATUS_IN_PROGRESS`
            * :attr:`UpgradeUnitGroupStatus.STATUS_NOT_STARTED`
            * :attr:`UpgradeUnitGroupStatus.STATUS_PAUSING`
            * :attr:`UpgradeUnitGroupStatus.STATUS_PAUSED`
            
             Upgrade status of upgrade unit group
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  upgrade_unit_count: :class:`long` or ``None``
        :param upgrade_unit_count: Number of upgrade units in the group format: int32
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.failed_count = failed_count
        self.group_id = group_id
        self.group_name = group_name
        self.percent_complete = percent_complete
        self.status = status
        self.upgrade_unit_count = upgrade_unit_count
        VapiStruct.__init__(self)


UpgradeUnitGroupStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.upgrade_unit_group_status', {
        'failed_count': type.OptionalType(type.IntegerType()),
        'group_id': type.OptionalType(type.StringType()),
        'group_name': type.OptionalType(type.StringType()),
        'percent_complete': type.OptionalType(type.DoubleType()),
        'status': type.OptionalType(type.StringType()),
        'upgrade_unit_count': type.OptionalType(type.IntegerType()),
    },
    UpgradeUnitGroupStatus,
    False,
    None))



class UpgradeUnitGroupStatusListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`UpgradeUnitGroupStatus` or ``None``
        :param results: Paged collection of upgrade status for upgrade unit groups
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


UpgradeUnitGroupStatusListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.upgrade_unit_group_status_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'UpgradeUnitGroupStatus'))),
    },
    UpgradeUnitGroupStatusListResult,
    False,
    None))



class UpgradeUnitList(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'list': 'list',
                            }

    def __init__(self,
                 list=None,
                ):
        """
        :type  list: :class:`list` of :class:`UpgradeUnit` or ``None``
        :param list: Collection of Upgrade units
        """
        self.list = list
        VapiStruct.__init__(self)


UpgradeUnitList._set_binding_type(type.StructType(
    'com.vmware.nsx.model.upgrade_unit_list', {
        'list': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'UpgradeUnit'))),
    },
    UpgradeUnitList,
    False,
    None))



class UpgradeUnitListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`UpgradeUnit` or ``None``
        :param results: Paged Collection of Upgrade units
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


UpgradeUnitListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.upgrade_unit_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'UpgradeUnit'))),
    },
    UpgradeUnitListResult,
    False,
    None))



class UpgradeUnitStatus(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    STATUS_SUCCESS = "SUCCESS"
    """


    """
    STATUS_FAILED = "FAILED"
    """


    """
    STATUS_IN_PROGRESS = "IN_PROGRESS"
    """


    """
    STATUS_NOT_STARTED = "NOT_STARTED"
    """


    """
    STATUS_PAUSING = "PAUSING"
    """


    """
    STATUS_PAUSED = "PAUSED"
    """


    """



    _canonical_to_pep_names = {
                            'display_name': 'display_name',
                            'errors': 'errors',
                            'id': 'id',
                            'metadata': 'metadata',
                            'percent_complete': 'percent_complete',
                            'status': 'status',
                            }

    def __init__(self,
                 display_name=None,
                 errors=None,
                 id=None,
                 metadata=None,
                 percent_complete=None,
                 status=None,
                ):
        """
        :type  display_name: :class:`str` or ``None``
        :param display_name: Name of upgrade unit
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  errors: :class:`list` of :class:`str` or ``None``
        :param errors: List of errors occurred during upgrade of this upgrade unit
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  id: :class:`str` or ``None``
        :param id: Identifier of upgrade unit
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  metadata: :class:`list` of :class:`KeyValuePair` or ``None``
        :param metadata: Metadata about upgrade unit
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  percent_complete: :class:`float` or ``None``
        :param percent_complete: Indicator of upgrade progress in percentage
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  status: :class:`str` or ``None``
        :param status: Possible values are: 
            
            * :attr:`UpgradeUnitStatus.STATUS_SUCCESS`
            * :attr:`UpgradeUnitStatus.STATUS_FAILED`
            * :attr:`UpgradeUnitStatus.STATUS_IN_PROGRESS`
            * :attr:`UpgradeUnitStatus.STATUS_NOT_STARTED`
            * :attr:`UpgradeUnitStatus.STATUS_PAUSING`
            * :attr:`UpgradeUnitStatus.STATUS_PAUSED`
            
             Status of upgrade unit
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.display_name = display_name
        self.errors = errors
        self.id = id
        self.metadata = metadata
        self.percent_complete = percent_complete
        self.status = status
        VapiStruct.__init__(self)


UpgradeUnitStatus._set_binding_type(type.StructType(
    'com.vmware.nsx.model.upgrade_unit_status', {
        'display_name': type.OptionalType(type.StringType()),
        'errors': type.OptionalType(type.ListType(type.StringType())),
        'id': type.OptionalType(type.StringType()),
        'metadata': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'KeyValuePair'))),
        'percent_complete': type.OptionalType(type.DoubleType()),
        'status': type.OptionalType(type.StringType()),
    },
    UpgradeUnitStatus,
    False,
    None))



class UpgradeUnitStatusListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`UpgradeUnitStatus` or ``None``
        :param results: Paged Collection of upgrade units status
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


UpgradeUnitStatusListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.upgrade_unit_status_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'UpgradeUnitStatus'))),
    },
    UpgradeUnitStatusListResult,
    False,
    None))



class UpgradeUnitTypeStats(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'node_count': 'node_count',
                            'node_with_issues_count': 'node_with_issues_count',
                            'type': 'type',
                            'version': 'version',
                            }

    def __init__(self,
                 node_count=None,
                 node_with_issues_count=None,
                 type=None,
                 version=None,
                ):
        """
        :type  node_count: :class:`long` or ``None``
        :param node_count: Number of nodes format: int32
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  node_with_issues_count: :class:`long` or ``None``
        :param node_with_issues_count: Number of nodes with issues that may cause upgrade failure format:
            int32
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  type: :class:`str` or ``None``
        :param type: Type of upgrade unit
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  version: :class:`str` or ``None``
        :param version: Version of the upgrade unit
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.node_count = node_count
        self.node_with_issues_count = node_with_issues_count
        self.type = type
        self.version = version
        VapiStruct.__init__(self)


UpgradeUnitTypeStats._set_binding_type(type.StructType(
    'com.vmware.nsx.model.upgrade_unit_type_stats', {
        'node_count': type.OptionalType(type.IntegerType()),
        'node_with_issues_count': type.OptionalType(type.IntegerType()),
        'type': type.OptionalType(type.StringType()),
        'version': type.OptionalType(type.StringType()),
    },
    UpgradeUnitTypeStats,
    False,
    None))



class UpgradeUnitTypeStatsList(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`UpgradeUnitTypeStats` or ``None``
        :param results: List of upgrade unit type stats
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


UpgradeUnitTypeStatsList._set_binding_type(type.StructType(
    'com.vmware.nsx.model.upgrade_unit_type_stats_list', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'UpgradeUnitTypeStats'))),
    },
    UpgradeUnitTypeStatsList,
    False,
    None))



class Uplink(VapiStruct):
    """
    Object to identify an uplink based on its type and name

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    UPLINK_TYPE_PNIC = "PNIC"
    """


    """
    UPLINK_TYPE_LAG = "LAG"
    """


    """



    _canonical_to_pep_names = {
                            'uplink_name': 'uplink_name',
                            'uplink_type': 'uplink_type',
                            }

    def __init__(self,
                 uplink_name=None,
                 uplink_type=None,
                ):
        """
        :type  uplink_name: :class:`str` or ``None``
        :param uplink_name: Name of this uplink
        :type  uplink_type: :class:`str` or ``None``
        :param uplink_type: Possible values are: 
            
            * :attr:`Uplink.UPLINK_TYPE_PNIC`
            * :attr:`Uplink.UPLINK_TYPE_LAG`
            
             Type of the uplink
        """
        self.uplink_name = uplink_name
        self.uplink_type = uplink_type
        VapiStruct.__init__(self)


Uplink._set_binding_type(type.StructType(
    'com.vmware.nsx.model.uplink', {
        'uplink_name': type.OptionalType(type.StringType()),
        'uplink_type': type.OptionalType(type.StringType()),
    },
    Uplink,
    False,
    None))



class UplinkHostSwitchProfile(VapiStruct):
    """
    Profile for uplink policies

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "UplinkHostSwitchProfile"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    OVERLAY_ENCAP_VXLAN = "VXLAN"
    """


    """
    OVERLAY_ENCAP_GENEVE = "GENEVE"
    """


    """



    _canonical_to_pep_names = {
                            'lags': 'lags',
                            'mtu': 'mtu',
                            'named_teamings': 'named_teamings',
                            'overlay_encap': 'overlay_encap',
                            'teaming': 'teaming',
                            'transport_vlan': 'transport_vlan',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'required_capabilities': 'required_capabilities',
                            }

    def __init__(self,
                 lags=None,
                 mtu=None,
                 named_teamings=None,
                 overlay_encap=None,
                 teaming=None,
                 transport_vlan=None,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='UplinkHostSwitchProfile',
                 tags=None,
                 required_capabilities=None,
                ):
        """
        :type  lags: :class:`list` of :class:`Lag` or ``None``
        :param lags: list of LACP group
        :type  mtu: :class:`long` or ``None``
        :param mtu: Maximum Transmission Unit used for uplinks format: int32
        :type  named_teamings: :class:`list` of :class:`NamedTeamingPolicy` or ``None``
        :param named_teamings: List of named uplink teaming policies that can be used by logical
            switches
        :type  overlay_encap: :class:`str` or ``None``
        :param overlay_encap: Possible values are: 
            
            * :attr:`UplinkHostSwitchProfile.OVERLAY_ENCAP_VXLAN`
            * :attr:`UplinkHostSwitchProfile.OVERLAY_ENCAP_GENEVE`
            
             The protocol used to encapsulate overlay traffic
        :type  teaming: :class:`TeamingPolicy` or ``None``
        :param teaming: Default TeamingPolicy associated with this UplinkProfile
        :type  transport_vlan: :class:`long` or ``None``
        :param transport_vlan: VLAN used for tagging Overlay traffic of associated HostSwitch
            format: int64
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            *
              :attr:`BaseHostSwitchProfile.RESOURCE_TYPE_UPLINKHOSTSWITCHPROFILE`
            * :attr:`BaseHostSwitchProfile.RESOURCE_TYPE_LLDPHOSTSWITCHPROFILE`
            * :attr:`BaseHostSwitchProfile.RESOURCE_TYPE_NIOCPROFILE`
            *
              :attr:`BaseHostSwitchProfile.RESOURCE_TYPE_EXTRACONFIGHOSTSWITCHPROFILE`
            
             Supported HostSwitch profiles.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  required_capabilities: :class:`list` of :class:`str` or ``None``
        :param required_capabilities: 
        """
        self.lags = lags
        self.mtu = mtu
        self.named_teamings = named_teamings
        self.overlay_encap = overlay_encap
        self.teaming = teaming
        self.transport_vlan = transport_vlan
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        self.required_capabilities = required_capabilities
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

UplinkHostSwitchProfile._set_binding_type(type.StructType(
    'com.vmware.nsx.model.uplink_host_switch_profile', {
        'lags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Lag'))),
        'mtu': type.OptionalType(type.IntegerType()),
        'named_teamings': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NamedTeamingPolicy'))),
        'overlay_encap': type.OptionalType(type.StringType()),
        'teaming': type.OptionalType(type.ReferenceType(__name__, 'TeamingPolicy')),
        'transport_vlan': type.OptionalType(type.IntegerType()),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'required_capabilities': type.OptionalType(type.ListType(type.StringType())),
    },
    UplinkHostSwitchProfile,
    False,
    None))



class UrlAlias(VapiStruct):
    """
    Short name or alias of a url. It is used to represent the url.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'alias': 'alias',
                            'query': 'query',
                            'url': 'url',
                            }

    def __init__(self,
                 alias=None,
                 query=None,
                 url=None,
                ):
        """
        :type  alias: :class:`str` or ``None``
        :param alias: 
        :type  query: :class:`str` or ``None``
        :param query: Search query to be applied, if any. If query string is not
            provided, it will be ignored.
        :type  url: :class:`str` or ``None``
        :param url: Url to fetch data from.
        """
        self.alias = alias
        self.query = query
        self.url = url
        VapiStruct.__init__(self)


UrlAlias._set_binding_type(type.StructType(
    'com.vmware.nsx.model.url_alias', {
        'alias': type.OptionalType(type.StringType()),
        'query': type.OptionalType(type.StringType()),
        'url': type.OptionalType(type.StringType()),
    },
    UrlAlias,
    False,
    None))



class UserInfo(VapiStruct):
    """
    Authenticated User Info

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'roles': 'roles',
                            'user_name': 'user_name',
                            }

    def __init__(self,
                 roles=None,
                 user_name=None,
                ):
        """
        :type  roles: :class:`list` of :class:`NsxRole` or ``None``
        :param roles: Permissions
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  user_name: :class:`str` or ``None``
        :param user_name: User Name
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.roles = roles
        self.user_name = user_name
        VapiStruct.__init__(self)


UserInfo._set_binding_type(type.StructType(
    'com.vmware.nsx.model.user_info', {
        'roles': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NsxRole'))),
        'user_name': type.OptionalType(type.StringType()),
    },
    UserInfo,
    False,
    None))



class UsernamePasswordLoginCredential(VapiStruct):
    """
    A login credential specifying a username and password

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "UsernamePasswordLoginCredential"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'password': 'password',
                            'thumbprint': 'thumbprint',
                            'username': 'username',
                            'credential_type': 'credential_type',
                            }

    def __init__(self,
                 password=None,
                 thumbprint=None,
                 username=None,
                 credential_type='UsernamePasswordLoginCredential',
                ):
        """
        :type  password: :class:`str` or ``None``
        :param password: The authentication password for login
        :type  thumbprint: :class:`str` or ``None``
        :param thumbprint: Thumbprint of the login server
        :type  username: :class:`str` or ``None``
        :param username: The username for login
        :type  credential_type: :class:`str`
        :param credential_type: Possible values are 'UsernamePasswordLoginCredential',
            'VerifiableAsymmetricLoginCredential', 'SessionLoginCredential'.
        """
        self.password = password
        self.thumbprint = thumbprint
        self.username = username
        self._credential_type = credential_type
        VapiStruct.__init__(self)

    @property
    def credential_type(self):
        """
        Return the discriminator value
        """
        return self._credential_type

UsernamePasswordLoginCredential._set_binding_type(type.StructType(
    'com.vmware.nsx.model.username_password_login_credential', {
        'password': type.OptionalType(type.StringType()),
        'thumbprint': type.OptionalType(type.StringType()),
        'username': type.OptionalType(type.StringType()),
        'credential_type': type.StringType(),
    },
    UsernamePasswordLoginCredential,
    False,
    None))



class VIPSubnet(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'active_vip_addresses': 'active_vip_addresses',
                            'prefix_length': 'prefix_length',
                            }

    def __init__(self,
                 active_vip_addresses=None,
                 prefix_length=None,
                ):
        """
        :type  active_vip_addresses: :class:`list` of :class:`str` or ``None``
        :param active_vip_addresses: Array of IP address subnets which will be used as floating IP
            addresses. | These IPs will move and will be owned by Active node.
            format: ip
        :type  prefix_length: :class:`long` or ``None``
        :param prefix_length: Subnet Prefix Length format: int64
        """
        self.active_vip_addresses = active_vip_addresses
        self.prefix_length = prefix_length
        VapiStruct.__init__(self)


VIPSubnet._set_binding_type(type.StructType(
    'com.vmware.nsx.model.VIP_subnet', {
        'active_vip_addresses': type.OptionalType(type.ListType(type.StringType())),
        'prefix_length': type.OptionalType(type.IntegerType()),
    },
    VIPSubnet,
    False,
    None))



class VMDeploymentProgressState(VapiStruct):
    """
    Deployment progress state of node VM. This Object contains name of current
    deployment step and overall progress percentage.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'current_step_title': 'current_step_title',
                            'progress': 'progress',
                            }

    def __init__(self,
                 current_step_title=None,
                 progress=None,
                ):
        """
        :type  current_step_title: :class:`str` or ``None``
        :param current_step_title: Name of the current running step of deployment
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  progress: :class:`long` or ``None``
        :param progress: Overall progress percentage of deployment completed format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.current_step_title = current_step_title
        self.progress = progress
        VapiStruct.__init__(self)


VMDeploymentProgressState._set_binding_type(type.StructType(
    'com.vmware.nsx.model.VM_deployment_progress_state', {
        'current_step_title': type.OptionalType(type.StringType()),
        'progress': type.OptionalType(type.IntegerType()),
    },
    VMDeploymentProgressState,
    False,
    None))



class ValidationError(VapiStruct):
    """
    Error while applying transport node profile on discovered node

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'discovered_node_id': 'discovered_node_id',
                            'error_message': 'error_message',
                            }

    def __init__(self,
                 discovered_node_id=None,
                 error_message=None,
                ):
        """
        :type  discovered_node_id: :class:`str` or ``None``
        :param discovered_node_id: Discovered Node Id
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  error_message: :class:`str` or ``None``
        :param error_message: Validation error message
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.discovered_node_id = discovered_node_id
        self.error_message = error_message
        VapiStruct.__init__(self)


ValidationError._set_binding_type(type.StructType(
    'com.vmware.nsx.model.validation_error', {
        'discovered_node_id': type.OptionalType(type.StringType()),
        'error_message': type.OptionalType(type.StringType()),
    },
    ValidationError,
    False,
    None))



class VdsTopology(VapiStruct):
    """
    VDS details where NVDS will be migrated to

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    VDS_STATUS_PENDING_TOPOLOGY = "PENDING_TOPOLOGY"
    """


    """
    VDS_STATUS_APPLYING_TOPOLOGY = "APPLYING_TOPOLOGY"
    """


    """
    VDS_STATUS_APPLY_TOPOLOGY_FAILED = "APPLY_TOPOLOGY_FAILED"
    """


    """
    VDS_STATUS_READY = "READY"
    """


    """



    _canonical_to_pep_names = {
                            'data_center_id': 'data_center_id',
                            'status_details': 'status_details',
                            'transport_node_id': 'transport_node_id',
                            'vds_config': 'vds_config',
                            'vds_name': 'vds_name',
                            'vds_status': 'vds_status',
                            'vmknic': 'vmknic',
                            }

    def __init__(self,
                 data_center_id=None,
                 status_details=None,
                 transport_node_id=None,
                 vds_config=None,
                 vds_name=None,
                 vds_status=None,
                 vmknic=None,
                ):
        """
        :type  data_center_id: :class:`str` or ``None``
        :param data_center_id: Identifier of datacenter where VDS will be created
        :type  status_details: :class:`list` of :class:`str` or ``None``
        :param status_details: Details of the VDS configuration status
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  transport_node_id: :class:`list` of :class:`str` or ``None``
        :param transport_node_id: Transport node identifiers on which NVDS(s) being upgraded to VDS
        :type  vds_config: :class:`DVSConfig` or ``None``
        :param vds_config: VDS configuration
        :type  vds_name: :class:`str` or ``None``
        :param vds_name: VDS name that will be created under above datacenter
        :type  vds_status: :class:`str` or ``None``
        :param vds_status: Possible values are: 
            
            * :attr:`VdsTopology.VDS_STATUS_PENDING_TOPOLOGY`
            * :attr:`VdsTopology.VDS_STATUS_APPLYING_TOPOLOGY`
            * :attr:`VdsTopology.VDS_STATUS_APPLY_TOPOLOGY_FAILED`
            * :attr:`VdsTopology.VDS_STATUS_READY`
            
             Status of the VDS configuration
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  vmknic: :class:`list` of :class:`str` or ``None``
        :param vmknic: Virtual network interfaces that will be moved from VLAN Logical
            switch to Distributed Virtual PortGroup
        """
        self.data_center_id = data_center_id
        self.status_details = status_details
        self.transport_node_id = transport_node_id
        self.vds_config = vds_config
        self.vds_name = vds_name
        self.vds_status = vds_status
        self.vmknic = vmknic
        VapiStruct.__init__(self)


VdsTopology._set_binding_type(type.StructType(
    'com.vmware.nsx.model.vds_topology', {
        'data_center_id': type.OptionalType(type.StringType()),
        'status_details': type.OptionalType(type.ListType(type.StringType())),
        'transport_node_id': type.OptionalType(type.ListType(type.StringType())),
        'vds_config': type.OptionalType(type.ReferenceType(__name__, 'DVSConfig')),
        'vds_name': type.OptionalType(type.StringType()),
        'vds_status': type.OptionalType(type.StringType()),
        'vmknic': type.OptionalType(type.ListType(type.StringType())),
    },
    VdsTopology,
    False,
    None))



class VdsUplink(VapiStruct):
    """
    If Virtual Distributed Switch is used as a HostSwitch to configure
    TransportNode or TransportNodeProfie, this mapping should be specified. You
    can either use vds_uplink_name or vds_lag_name to associate with
    uplink_name from UplinkHostSwitch profile.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'uplink_name': 'uplink_name',
                            'vds_lag_name': 'vds_lag_name',
                            'vds_uplink_name': 'vds_uplink_name',
                            }

    def __init__(self,
                 uplink_name=None,
                 vds_lag_name=None,
                 vds_uplink_name=None,
                ):
        """
        :type  uplink_name: :class:`str` or ``None``
        :param uplink_name: This name is from UplinkHostSwitch profile that is associated with
            the HostSwitch specified in TransportNode or TransportNodeProfile
            configuration. This name will be used as an alias to either VDS
            uplink or lag in other configuration.
        :type  vds_lag_name: :class:`str` or ``None``
        :param vds_lag_name: LAG name that is connected to Physical NIC on a host from vSphere.
        :type  vds_uplink_name: :class:`str` or ``None``
        :param vds_uplink_name: Uplink name of VDS that is connected to Physical NIC on a host from
            vSphere.
        """
        self.uplink_name = uplink_name
        self.vds_lag_name = vds_lag_name
        self.vds_uplink_name = vds_uplink_name
        VapiStruct.__init__(self)


VdsUplink._set_binding_type(type.StructType(
    'com.vmware.nsx.model.vds_uplink', {
        'uplink_name': type.OptionalType(type.StringType()),
        'vds_lag_name': type.OptionalType(type.StringType()),
        'vds_uplink_name': type.OptionalType(type.StringType()),
    },
    VdsUplink,
    False,
    None))



class VendorTemplate(VapiStruct):
    """
    Vendor Templates are registered by the partner service manager to be used
    in the service profile. They contain named (k-v) pairs.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    FUNCTIONALITY_NG_FW = "NG_FW"
    """


    """
    FUNCTIONALITY_IDS_IPS = "IDS_IPS"
    """


    """
    FUNCTIONALITY_NET_MON = "NET_MON"
    """


    """
    FUNCTIONALITY_HCX = "HCX"
    """


    """
    FUNCTIONALITY_BYOD = "BYOD"
    """


    """
    FUNCTIONALITY_EPP = "EPP"
    """


    """
    REDIRECTION_ACTION_PUNT = "PUNT"
    """


    """
    REDIRECTION_ACTION_COPY = "COPY"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'attributes': 'attributes',
                            'functionality': 'functionality',
                            'redirection_action': 'redirection_action',
                            'service_id': 'service_id',
                            'vendor_template_key': 'vendor_template_key',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 attributes=None,
                 functionality=None,
                 redirection_action=None,
                 service_id=None,
                 vendor_template_key=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  attributes: :class:`list` of :class:`Attribute` or ``None``
        :param attributes: List of attributes specific to a partner for which the vendor
            template is created. There attributes are passed on to the partner
            appliance and is opaque to the NSX Manager. Attributes are not
            supported by guest introspection service.
        :type  functionality: :class:`str` or ``None``
        :param functionality: Possible values are: 
            
            * :attr:`VendorTemplate.FUNCTIONALITY_NG_FW`
            * :attr:`VendorTemplate.FUNCTIONALITY_IDS_IPS`
            * :attr:`VendorTemplate.FUNCTIONALITY_NET_MON`
            * :attr:`VendorTemplate.FUNCTIONALITY_HCX`
            * :attr:`VendorTemplate.FUNCTIONALITY_BYOD`
            * :attr:`VendorTemplate.FUNCTIONALITY_EPP`
            
            The capabilities provided by the services. Needs to be one of the
            following | NG_FW - Next Generation Firewall | IDS_IPS - Intrusion
            detection System / Intrusion Prevention System | NET_MON - Network
            Monitoring | HCX - Hybrid Cloud Exchange | BYOD - Bring Your Own
            Device | EPP - Endpoint Protection.(Third party AntiVirus partners
            using NXGI should use this functionality for the service)
        :type  redirection_action: :class:`str` or ``None``
        :param redirection_action: Possible values are: 
            
            * :attr:`VendorTemplate.REDIRECTION_ACTION_PUNT`
            * :attr:`VendorTemplate.REDIRECTION_ACTION_COPY`
            
            The redirection action represents if the packet is exclusively
            redirected to the service, or if a copy is forwarded to the
            service. Service profile inherits the redirection action specified
            at the vendor template and cannot override the action specified at
            the vendor template. Redirection action is not applicable to guest
            introspection service.
        :type  service_id: :class:`str` or ``None``
        :param service_id: The service to which the vendor template belongs.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  vendor_template_key: :class:`str` or ``None``
        :param vendor_template_key: Different VMs in data center can have Different protection levels
            as specified by administrator in the policy. The identifier for the
            policy with which the partner appliance identifies this policy.
            This identifier will be passed to the partner appliance at runtime
            to specify which protection level is applicable for the VM being
            protected.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.attributes = attributes
        self.functionality = functionality
        self.redirection_action = redirection_action
        self.service_id = service_id
        self.vendor_template_key = vendor_template_key
        VapiStruct.__init__(self)


VendorTemplate._set_binding_type(type.StructType(
    'com.vmware.nsx.model.vendor_template', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'attributes': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Attribute'))),
        'functionality': type.OptionalType(type.StringType()),
        'redirection_action': type.OptionalType(type.StringType()),
        'service_id': type.OptionalType(type.StringType()),
        'vendor_template_key': type.OptionalType(type.StringType()),
    },
    VendorTemplate,
    False,
    None))



class VendorTemplateListResult(VapiStruct):
    """
    Vendor Template List

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`VendorTemplate` or ``None``
        :param results: List of the Service-Insertion Services. The list has to be
            homogenous.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


VendorTemplateListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.vendor_template_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'VendorTemplate'))),
    },
    VendorTemplateListResult,
    False,
    None))



class VerifiableAsymmetricLoginCredential(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "VerifiableAsymmetricLoginCredential"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'asymmetric_credential': 'asymmetric_credential',
                            'credential_key': 'credential_key',
                            'credential_verifier': 'credential_verifier',
                            'credential_type': 'credential_type',
                            }

    def __init__(self,
                 asymmetric_credential=None,
                 credential_key=None,
                 credential_verifier=None,
                 credential_type='VerifiableAsymmetricLoginCredential',
                ):
        """
        :type  asymmetric_credential: :class:`str` or ``None``
        :param asymmetric_credential: Asymmetric login credential
        :type  credential_key: :class:`str` or ``None``
        :param credential_key: Credential key
        :type  credential_verifier: :class:`str` or ``None``
        :param credential_verifier: Credential verifier
        :type  credential_type: :class:`str`
        :param credential_type: Possible values are 'UsernamePasswordLoginCredential',
            'VerifiableAsymmetricLoginCredential', 'SessionLoginCredential'.
        """
        self.asymmetric_credential = asymmetric_credential
        self.credential_key = credential_key
        self.credential_verifier = credential_verifier
        self._credential_type = credential_type
        VapiStruct.__init__(self)

    @property
    def credential_type(self):
        """
        Return the discriminator value
        """
        return self._credential_type

VerifiableAsymmetricLoginCredential._set_binding_type(type.StructType(
    'com.vmware.nsx.model.verifiable_asymmetric_login_credential', {
        'asymmetric_credential': type.OptionalType(type.StringType()),
        'credential_key': type.OptionalType(type.StringType()),
        'credential_verifier': type.OptionalType(type.StringType()),
        'credential_type': type.StringType(),
    },
    VerifiableAsymmetricLoginCredential,
    False,
    None))



class VersionList(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'acceptable_versions': 'acceptable_versions',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 acceptable_versions=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  acceptable_versions: :class:`list` of :class:`str` or ``None``
        :param acceptable_versions: List of component versions
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.acceptable_versions = acceptable_versions
        VapiStruct.__init__(self)


VersionList._set_binding_type(type.StructType(
    'com.vmware.nsx.model.version_list', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'acceptable_versions': type.OptionalType(type.ListType(type.StringType())),
    },
    VersionList,
    False,
    None))



class VidmInfo(VapiStruct):
    """
    Vidm Info

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    TYPE_USER = "remote_user"
    """


    """
    TYPE_GROUP = "remote_group"
    """


    """



    _canonical_to_pep_names = {
                            'display_name': 'display_name',
                            'name': 'name',
                            'type': 'type',
                            }

    def __init__(self,
                 display_name=None,
                 name=None,
                 type=None,
                ):
        """
        :type  display_name: :class:`str` or ``None``
        :param display_name: User's Full Name Or User Group's Display Name
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  name: :class:`str` or ``None``
        :param name: Username Or Groupname
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  type: :class:`str` or ``None``
        :param type: Possible values are: 
            
            * :attr:`VidmInfo.TYPE_USER`
            * :attr:`VidmInfo.TYPE_GROUP`
            
             Type
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.display_name = display_name
        self.name = name
        self.type = type
        VapiStruct.__init__(self)


VidmInfo._set_binding_type(type.StructType(
    'com.vmware.nsx.model.vidm_info', {
        'display_name': type.OptionalType(type.StringType()),
        'name': type.OptionalType(type.StringType()),
        'type': type.OptionalType(type.StringType()),
    },
    VidmInfo,
    False,
    None))



class VidmInfoListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`VidmInfo` or ``None``
        :param results: List results
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


VidmInfoListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.vidm_info_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'VidmInfo'))),
    },
    VidmInfoListResult,
    False,
    None))



class View(VapiStruct):
    """
    Describes the configuration of a view to be displayed on the dashboard.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'exclude_roles': 'exclude_roles',
                            'include_roles': 'include_roles',
                            'shared': 'shared',
                            'weight': 'weight',
                            'widgets': 'widgets',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 exclude_roles=None,
                 include_roles=None,
                 shared=None,
                 weight=None,
                 widgets=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Title of the widget.
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  exclude_roles: :class:`str` or ``None``
        :param exclude_roles: Comma separated list of roles to which the shared view is not
            visible. Allows user to prevent the visibility of a shared view to
            the specified roles. User defined roles can also be specified in
            the list. The roles can be obtained via GET /api/v1/aaa/roles.
            Please visit API documentation for details about roles. If
            include_roles is specified then exclude_roles cannot be specified.
        :type  include_roles: :class:`str` or ``None``
        :param include_roles: Comma separated list of roles to which the shared view is visible.
            Allows user to specify the visibility of a shared view to the
            specified roles. User defined roles can also be specified in the
            list. The roles can be obtained via GET /api/v1/aaa/roles. Please
            visit API documentation for details about roles.
        :type  shared: :class:`bool` or ``None``
        :param shared: Defaults to false. Set to true to publish the view to other users.
            The widgets of a shared view are visible to other users.
        :type  weight: :class:`long` or ``None``
        :param weight: Determines placement of view relative to other views. The lower the
            weight, the higher it is in the placement order. format: int32
        :type  widgets: :class:`list` of :class:`WidgetItem` or ``None``
        :param widgets: Array of widgets that are part of the view.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.exclude_roles = exclude_roles
        self.include_roles = include_roles
        self.shared = shared
        self.weight = weight
        self.widgets = widgets
        VapiStruct.__init__(self)


View._set_binding_type(type.StructType(
    'com.vmware.nsx.model.view', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'exclude_roles': type.OptionalType(type.StringType()),
        'include_roles': type.OptionalType(type.StringType()),
        'shared': type.OptionalType(type.BooleanType()),
        'weight': type.OptionalType(type.IntegerType()),
        'widgets': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'WidgetItem'))),
    },
    View,
    False,
    None))



class ViewList(VapiStruct):
    """
    Represents a list of views.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'views': 'views',
                            }

    def __init__(self,
                 views=None,
                ):
        """
        :type  views: :class:`list` of :class:`View` or ``None``
        :param views: Array of views
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.views = views
        VapiStruct.__init__(self)


ViewList._set_binding_type(type.StructType(
    'com.vmware.nsx.model.view_list', {
        'views': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'View'))),
    },
    ViewList,
    False,
    None))



class VifAttachmentContext(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "VifAttachmentContext"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    VIF_TYPE_PARENT = "PARENT"
    """


    """
    VIF_TYPE_CHILD = "CHILD"
    """


    """
    VIF_TYPE_INDEPENDENT = "INDEPENDENT"
    """


    """



    _canonical_to_pep_names = {
                            'app_id': 'app_id',
                            'parent_vif_id': 'parent_vif_id',
                            'traffic_tag': 'traffic_tag',
                            'transport_node_uuid': 'transport_node_uuid',
                            'vif_type': 'vif_type',
                            'allocate_addresses': 'allocate_addresses',
                            'resource_type': 'resource_type',
                            }

    def __init__(self,
                 app_id=None,
                 parent_vif_id=None,
                 traffic_tag=None,
                 transport_node_uuid=None,
                 vif_type=None,
                 allocate_addresses=None,
                 resource_type='VifAttachmentContext',
                ):
        """
        :type  app_id: :class:`str` or ``None``
        :param app_id: An application ID used to identify / look up a child VIF behind a
            parent VIF. Only effective when vif_type is CHILD.
        :type  parent_vif_id: :class:`str` or ``None``
        :param parent_vif_id: VIF ID of the parent VIF if vif_type is CHILD
        :type  traffic_tag: :class:`long` or ``None``
        :param traffic_tag: Current we use VLAN id as the traffic tag. Only effective when
            vif_type is CHILD. Each logical port inside a container must have a
            unique traffic tag. If the traffic_tag is not unique, no error is
            generated, but traffic will not be delivered to any port with a
            non-unique tag. format: int32
        :type  transport_node_uuid: :class:`str` or ``None``
        :param transport_node_uuid: Only effective when vif_type is INDEPENDENT. Each logical port
            inside a bare metal server or container must have a transport node
            UUID. We use transport node ID as transport node UUID.
        :type  vif_type: :class:`str` or ``None``
        :param vif_type: Possible values are: 
            
            * :attr:`VifAttachmentContext.VIF_TYPE_PARENT`
            * :attr:`VifAttachmentContext.VIF_TYPE_CHILD`
            * :attr:`VifAttachmentContext.VIF_TYPE_INDEPENDENT`
            
             Type of the VIF attached to logical port
        :type  allocate_addresses: :class:`str` or ``None``
        :param allocate_addresses: Possible values are: 
            
            * :attr:`AttachmentContext.ALLOCATE_ADDRESSES_IPPOOL`
            * :attr:`AttachmentContext.ALLOCATE_ADDRESSES_MACPOOL`
            * :attr:`AttachmentContext.ALLOCATE_ADDRESSES_BOTH`
            * :attr:`AttachmentContext.ALLOCATE_ADDRESSES_NONE`
            
            A flag to indicate whether to allocate addresses from allocation
            pools bound to the parent logical switch.
        :type  resource_type: :class:`str`
        :param resource_type: Used to identify which concrete class it is
        """
        self.app_id = app_id
        self.parent_vif_id = parent_vif_id
        self.traffic_tag = traffic_tag
        self.transport_node_uuid = transport_node_uuid
        self.vif_type = vif_type
        self.allocate_addresses = allocate_addresses
        self._resource_type = resource_type
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

VifAttachmentContext._set_binding_type(type.StructType(
    'com.vmware.nsx.model.vif_attachment_context', {
        'app_id': type.OptionalType(type.StringType()),
        'parent_vif_id': type.OptionalType(type.StringType()),
        'traffic_tag': type.OptionalType(type.IntegerType()),
        'transport_node_uuid': type.OptionalType(type.StringType()),
        'vif_type': type.OptionalType(type.StringType()),
        'allocate_addresses': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
    },
    VifAttachmentContext,
    False,
    None))



class VirtualMachine(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "VirtualMachine"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    POWER_STATE_VM_RUNNING = "VM_RUNNING"
    """


    """
    POWER_STATE_VM_STOPPED = "VM_STOPPED"
    """


    """
    POWER_STATE_VM_SUSPENDED = "VM_SUSPENDED"
    """


    """
    POWER_STATE_UNKNOWN = "UNKNOWN"
    """


    """
    TYPE_EDGE = "EDGE"
    """


    """
    TYPE_SERVICE = "SERVICE"
    """


    """
    TYPE_REGULAR = "REGULAR"
    """


    """



    _canonical_to_pep_names = {
                            'compute_ids': 'compute_ids',
                            'external_id': 'external_id',
                            'guest_info': 'guest_info',
                            'host_id': 'host_id',
                            'local_id_on_host': 'local_id_on_host',
                            'power_state': 'power_state',
                            'source': 'source',
                            'type': 'type',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_last_sync_time': 'last_sync_time',
                            'description': 'description',
                            'display_name': 'display_name',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            }

    def __init__(self,
                 compute_ids=None,
                 external_id=None,
                 guest_info=None,
                 host_id=None,
                 local_id_on_host=None,
                 power_state=None,
                 source=None,
                 type=None,
                 links=None,
                 schema=None,
                 self_=None,
                 last_sync_time=None,
                 description=None,
                 display_name=None,
                 resource_type='VirtualMachine',
                 tags=None,
                ):
        """
        :type  compute_ids: :class:`list` of :class:`str` or ``None``
        :param compute_ids: List of external compute ids of the virtual machine in the format
            'id-type-key:value' , list of external compute ids
            ['uuid:xxxx-xxxx-xxxx-xxxx', 'moIdOnHost:moref-11',
            'instanceUuid:xxxx-xxxx-xxxx-xxxx']
        :type  external_id: :class:`str` or ``None``
        :param external_id: Current external id of this virtual machine in the system.
        :type  guest_info: :class:`GuestInfo` or ``None``
        :param guest_info: Guest virtual machine details include OS name, computer name of
            guest VM. Currently this is supported for guests on ESXi that have
            VMware Tools installed.
        :type  host_id: :class:`str` or ``None``
        :param host_id: Id of the host in which this virtual machine exists.
        :type  local_id_on_host: :class:`str` or ``None``
        :param local_id_on_host: Id of the vm unique within the host.
        :type  power_state: :class:`str` or ``None``
        :param power_state: Possible values are: 
            
            * :attr:`VirtualMachine.POWER_STATE_VM_RUNNING`
            * :attr:`VirtualMachine.POWER_STATE_VM_STOPPED`
            * :attr:`VirtualMachine.POWER_STATE_VM_SUSPENDED`
            * :attr:`VirtualMachine.POWER_STATE_UNKNOWN`
            
             Current power state of this virtual machine in the system.
        :type  source: :class:`ResourceReference` or ``None``
        :param source: Reference of the Host or Public Cloud Gateway that reported the VM
        :type  type: :class:`str` or ``None``
        :param type: Possible values are: 
            
            * :attr:`VirtualMachine.TYPE_EDGE`
            * :attr:`VirtualMachine.TYPE_SERVICE`
            * :attr:`VirtualMachine.TYPE_REGULAR`
            
             Virtual Machine type; Edge, Service VM or other.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  last_sync_time: :class:`long` or ``None``
        :param last_sync_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  resource_type: :class:`str`
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        """
        self.compute_ids = compute_ids
        self.external_id = external_id
        self.guest_info = guest_info
        self.host_id = host_id
        self.local_id_on_host = local_id_on_host
        self.power_state = power_state
        self.source = source
        self.type = type
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.last_sync_time = last_sync_time
        self.description = description
        self.display_name = display_name
        self._resource_type = resource_type
        self.tags = tags
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

VirtualMachine._set_binding_type(type.StructType(
    'com.vmware.nsx.model.virtual_machine', {
        'compute_ids': type.OptionalType(type.ListType(type.StringType())),
        'external_id': type.OptionalType(type.StringType()),
        'guest_info': type.OptionalType(type.ReferenceType(__name__, 'GuestInfo')),
        'host_id': type.OptionalType(type.StringType()),
        'local_id_on_host': type.OptionalType(type.StringType()),
        'power_state': type.OptionalType(type.StringType()),
        'source': type.OptionalType(type.ReferenceType(__name__, 'ResourceReference')),
        'type': type.OptionalType(type.StringType()),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_last_sync_time': type.OptionalType(type.IntegerType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
    },
    VirtualMachine,
    False,
    None))



class VirtualMachineListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`VirtualMachine` or ``None``
        :param results: VirtualMachine list results
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


VirtualMachineListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.virtual_machine_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'VirtualMachine'))),
    },
    VirtualMachineListResult,
    False,
    None))



class VirtualMachineTagUpdate(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'external_id': 'external_id',
                            'tags': 'tags',
                            }

    def __init__(self,
                 external_id=None,
                 tags=None,
                ):
        """
        :type  external_id: :class:`str` or ``None``
        :param external_id: External id of the virtual machine to which tags are to be applied
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: List of tags to be applied to the virtual machine
        """
        self.external_id = external_id
        self.tags = tags
        VapiStruct.__init__(self)


VirtualMachineTagUpdate._set_binding_type(type.StructType(
    'com.vmware.nsx.model.virtual_machine_tag_update', {
        'external_id': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
    },
    VirtualMachineTagUpdate,
    False,
    None))



class VirtualNetworkInterface(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "VirtualNetworkInterface"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    OWNER_VM_TYPE_EDGE = "EDGE"
    """


    """
    OWNER_VM_TYPE_SERVICE = "SERVICE"
    """


    """
    OWNER_VM_TYPE_REGULAR = "REGULAR"
    """


    """



    _canonical_to_pep_names = {
                            'device_key': 'device_key',
                            'device_name': 'device_name',
                            'external_id': 'external_id',
                            'host_id': 'host_id',
                            'ip_address_info': 'ip_address_info',
                            'lport_attachment_id': 'lport_attachment_id',
                            'mac_address': 'mac_address',
                            'owner_vm_id': 'owner_vm_id',
                            'owner_vm_type': 'owner_vm_type',
                            'vm_local_id_on_host': 'vm_local_id_on_host',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_last_sync_time': 'last_sync_time',
                            'description': 'description',
                            'display_name': 'display_name',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            }

    def __init__(self,
                 device_key=None,
                 device_name=None,
                 external_id=None,
                 host_id=None,
                 ip_address_info=None,
                 lport_attachment_id=None,
                 mac_address=None,
                 owner_vm_id=None,
                 owner_vm_type=None,
                 vm_local_id_on_host=None,
                 links=None,
                 schema=None,
                 self_=None,
                 last_sync_time=None,
                 description=None,
                 display_name=None,
                 resource_type='VirtualNetworkInterface',
                 tags=None,
                ):
        """
        :type  device_key: :class:`str` or ``None``
        :param device_key: Device key of the virtual network interface.
        :type  device_name: :class:`str` or ``None``
        :param device_name: Device name of the virtual network interface.
        :type  external_id: :class:`str` or ``None``
        :param external_id: External Id of the virtual network inferface.
        :type  host_id: :class:`str` or ``None``
        :param host_id: Id of the host on which the vm exists.
        :type  ip_address_info: :class:`list` of :class:`IpAddressInfo` or ``None``
        :param ip_address_info: IP Addresses of the the virtual network interface, from various
            sources.
        :type  lport_attachment_id: :class:`str` or ``None``
        :param lport_attachment_id: LPort Attachment Id of the virtual network interface.
        :type  mac_address: :class:`str` or ``None``
        :param mac_address: MAC address of the virtual network interface.
        :type  owner_vm_id: :class:`str` or ``None``
        :param owner_vm_id: Id of the vm to which this virtual network interface belongs.
        :type  owner_vm_type: :class:`str` or ``None``
        :param owner_vm_type: Possible values are: 
            
            * :attr:`VirtualNetworkInterface.OWNER_VM_TYPE_EDGE`
            * :attr:`VirtualNetworkInterface.OWNER_VM_TYPE_SERVICE`
            * :attr:`VirtualNetworkInterface.OWNER_VM_TYPE_REGULAR`
            
             Owner virtual machine type; Edge, Service VM or other.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  vm_local_id_on_host: :class:`str` or ``None``
        :param vm_local_id_on_host: Id of the vm unique within the host.
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  last_sync_time: :class:`long` or ``None``
        :param last_sync_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  resource_type: :class:`str`
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        """
        self.device_key = device_key
        self.device_name = device_name
        self.external_id = external_id
        self.host_id = host_id
        self.ip_address_info = ip_address_info
        self.lport_attachment_id = lport_attachment_id
        self.mac_address = mac_address
        self.owner_vm_id = owner_vm_id
        self.owner_vm_type = owner_vm_type
        self.vm_local_id_on_host = vm_local_id_on_host
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.last_sync_time = last_sync_time
        self.description = description
        self.display_name = display_name
        self._resource_type = resource_type
        self.tags = tags
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

VirtualNetworkInterface._set_binding_type(type.StructType(
    'com.vmware.nsx.model.virtual_network_interface', {
        'device_key': type.OptionalType(type.StringType()),
        'device_name': type.OptionalType(type.StringType()),
        'external_id': type.OptionalType(type.StringType()),
        'host_id': type.OptionalType(type.StringType()),
        'ip_address_info': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IpAddressInfo'))),
        'lport_attachment_id': type.OptionalType(type.StringType()),
        'mac_address': type.OptionalType(type.StringType()),
        'owner_vm_id': type.OptionalType(type.StringType()),
        'owner_vm_type': type.OptionalType(type.StringType()),
        'vm_local_id_on_host': type.OptionalType(type.StringType()),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_last_sync_time': type.OptionalType(type.IntegerType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
    },
    VirtualNetworkInterface,
    False,
    None))



class VirtualNetworkInterfaceListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`VirtualNetworkInterface` or ``None``
        :param results: VirtualNetworkInterface list results
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


VirtualNetworkInterfaceListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.virtual_network_interface_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'VirtualNetworkInterface'))),
    },
    VirtualNetworkInterfaceListResult,
    False,
    None))



class VirtualPortgroup(VapiStruct):
    """
    Virtual portgroup on a virtual switch

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "VirtualPortgroup"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'cm_local_id': 'cm_local_id',
                            'external_id': 'external_id',
                            'origin_type': 'origin_type',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_last_sync_time': 'last_sync_time',
                            'description': 'description',
                            'display_name': 'display_name',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            }

    def __init__(self,
                 cm_local_id=None,
                 external_id=None,
                 origin_type=None,
                 links=None,
                 schema=None,
                 self_=None,
                 last_sync_time=None,
                 description=None,
                 display_name=None,
                 resource_type='VirtualPortgroup',
                 tags=None,
                ):
        """
        :type  cm_local_id: :class:`str` or ``None``
        :param cm_local_id: Id of the portgroup, eg. a mo-ref from VC.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  external_id: :class:`str` or ``None``
        :param external_id: External id of the virtual portgroup
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  origin_type: :class:`str` or ``None``
        :param origin_type: Portgroup type like DistributedVirtualPortgroup
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  last_sync_time: :class:`long` or ``None``
        :param last_sync_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  resource_type: :class:`str`
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        """
        self.cm_local_id = cm_local_id
        self.external_id = external_id
        self.origin_type = origin_type
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.last_sync_time = last_sync_time
        self.description = description
        self.display_name = display_name
        self._resource_type = resource_type
        self.tags = tags
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

VirtualPortgroup._set_binding_type(type.StructType(
    'com.vmware.nsx.model.virtual_portgroup', {
        'cm_local_id': type.OptionalType(type.StringType()),
        'external_id': type.OptionalType(type.StringType()),
        'origin_type': type.OptionalType(type.StringType()),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_last_sync_time': type.OptionalType(type.IntegerType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
    },
    VirtualPortgroup,
    False,
    None))



class VirtualServiceInstance(VapiStruct):
    """
    VirtualServiceInstance is a custom instance to be used when NSX is not
    handling the lifecycles of appliance/s and the user is not bringing their
    own appliance (BYOD).

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "VirtualServiceInstance"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'on_failure_policy': 'on_failure_policy',
                            'service_id': 'service_id',
                            'transport_type': 'transport_type',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='VirtualServiceInstance',
                 tags=None,
                 on_failure_policy=None,
                 service_id=None,
                 transport_type=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`BaseServiceInstance.RESOURCE_TYPE_SERVICEINSTANCE`
            * :attr:`BaseServiceInstance.RESOURCE_TYPE_BYODSERVICEINSTANCE`
            * :attr:`BaseServiceInstance.RESOURCE_TYPE_VIRTUALSERVICEINSTANCE`
            
            ServiceInstance is used when NSX handles the lifecyle of appliance.
            Deployment and appliance related all the information is necessary.
            ByodServiceInstance is a custom instance to be used when NSX is not
            handling the lifecycles of appliance/s. User will manage their own
            appliance (BYOD) to connect with NSX. VirtualServiceInstance is a a
            custom instance to be used when NSX is not handling the lifecycle
            of an appliance and when the user is not bringing their own
            appliance.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  on_failure_policy: :class:`str` or ``None``
        :param on_failure_policy: Possible values are: 
            
            * :attr:`BaseServiceInstance.ON_FAILURE_POLICY_ALLOW`
            * :attr:`BaseServiceInstance.ON_FAILURE_POLICY_BLOCK`
            
            Failure policy of the service instance - if it has to be different
            from the service. By default the service instance inherits the
            FailurePolicy of the service it belongs to.
        :type  service_id: :class:`str` or ``None``
        :param service_id: The Service to which the service instance is associated.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  transport_type: :class:`str` or ``None``
        :param transport_type: Possible values are: 
            
            * :attr:`BaseServiceInstance.TRANSPORT_TYPE_L2_BRIDGE`
            * :attr:`BaseServiceInstance.TRANSPORT_TYPE_L3_ROUTED`
            * :attr:`BaseServiceInstance.TRANSPORT_TYPE_NSH`
            * :attr:`BaseServiceInstance.TRANSPORT_TYPE_NA`
            
            Transport to be used by this service instance for deploying the
            Service-VM. This field is to be set Not Applicable(NA) if the
            service only caters to functionality EPP(Endpoint Protection).
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        self.on_failure_policy = on_failure_policy
        self.service_id = service_id
        self.transport_type = transport_type
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

VirtualServiceInstance._set_binding_type(type.StructType(
    'com.vmware.nsx.model.virtual_service_instance', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'on_failure_policy': type.OptionalType(type.StringType()),
        'service_id': type.OptionalType(type.StringType()),
        'transport_type': type.OptionalType(type.StringType()),
    },
    VirtualServiceInstance,
    False,
    None))



class VirtualSwitch(VapiStruct):
    """
    Virtual switch on a compute manager

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "VirtualSwitch"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'cm_local_id': 'cm_local_id',
                            'external_id': 'external_id',
                            'origin_id': 'origin_id',
                            'origin_type': 'origin_type',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_last_sync_time': 'last_sync_time',
                            'description': 'description',
                            'display_name': 'display_name',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            }

    def __init__(self,
                 cm_local_id=None,
                 external_id=None,
                 origin_id=None,
                 origin_type=None,
                 links=None,
                 schema=None,
                 self_=None,
                 last_sync_time=None,
                 description=None,
                 display_name=None,
                 resource_type='VirtualSwitch',
                 tags=None,
                ):
        """
        :type  cm_local_id: :class:`str` or ``None``
        :param cm_local_id: ID of the virtual switch in compute manager
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  external_id: :class:`str` or ``None``
        :param external_id: External id of the virtual switch
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  origin_id: :class:`str` or ``None``
        :param origin_id: ID of the compute manager where this virtual switch is discovered.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  origin_type: :class:`str` or ``None``
        :param origin_type: Switch type like VmwareDistributedVirtualSwitch
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  last_sync_time: :class:`long` or ``None``
        :param last_sync_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  resource_type: :class:`str`
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        """
        self.cm_local_id = cm_local_id
        self.external_id = external_id
        self.origin_id = origin_id
        self.origin_type = origin_type
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.last_sync_time = last_sync_time
        self.description = description
        self.display_name = display_name
        self._resource_type = resource_type
        self.tags = tags
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

VirtualSwitch._set_binding_type(type.StructType(
    'com.vmware.nsx.model.virtual_switch', {
        'cm_local_id': type.OptionalType(type.StringType()),
        'external_id': type.OptionalType(type.StringType()),
        'origin_id': type.OptionalType(type.StringType()),
        'origin_type': type.OptionalType(type.StringType()),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_last_sync_time': type.OptionalType(type.IntegerType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
    },
    VirtualSwitch,
    False,
    None))



class VirtualSwitchListResult(VapiStruct):
    """
    Virtual switch list result

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`VirtualSwitch` or ``None``
        :param results: Virtual switch list results
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


VirtualSwitchListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.virtual_switch_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'VirtualSwitch'))),
    },
    VirtualSwitchListResult,
    False,
    None))



class VlanMirrorSource(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "VlanMirrorSource"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'vlan_ids': 'vlan_ids',
                            'resource_type': 'resource_type',
                            }

    def __init__(self,
                 vlan_ids=None,
                 resource_type='VlanMirrorSource',
                ):
        """
        :type  vlan_ids: :class:`list` of :class:`long` or ``None``
        :param vlan_ids: Source VLAN ID list format: int64
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`MirrorSource.RESOURCE_TYPE_LOGICALPORTMIRRORSOURCE`
            * :attr:`MirrorSource.RESOURCE_TYPE_PNICMIRRORSOURCE`
            * :attr:`MirrorSource.RESOURCE_TYPE_VLANMIRRORSOURCE`
            * :attr:`MirrorSource.RESOURCE_TYPE_LOGICALSWITCHMIRRORSOURCE`
            
             Resource types of mirror source
        """
        self.vlan_ids = vlan_ids
        self._resource_type = resource_type
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

VlanMirrorSource._set_binding_type(type.StructType(
    'com.vmware.nsx.model.vlan_mirror_source', {
        'vlan_ids': type.OptionalType(type.ListType(type.IntegerType())),
        'resource_type': type.StringType(),
    },
    VlanMirrorSource,
    False,
    None))



class VlanTrunkSpec(VapiStruct):
    """
    VlanTrunkspec is used for specifying trunk VLAN id ranges.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'vlan_ranges': 'vlan_ranges',
                            }

    def __init__(self,
                 vlan_ranges=None,
                ):
        """
        :type  vlan_ranges: :class:`list` of :class:`TrunkVlanRange` or ``None``
        :param vlan_ranges: Trunk VLAN id ranges
        """
        self.vlan_ranges = vlan_ranges
        VapiStruct.__init__(self)


VlanTrunkSpec._set_binding_type(type.StructType(
    'com.vmware.nsx.model.vlan_trunk_spec', {
        'vlan_ranges': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'TrunkVlanRange'))),
    },
    VlanTrunkSpec,
    False,
    None))



class VmNicInfo(VapiStruct):
    """
    Contains a set of information of a VM on the network interfaces present on
    the partner appliance that needs to be configured by the NSX Manager.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'nic_infos': 'nic_infos',
                            }

    def __init__(self,
                 nic_infos=None,
                ):
        """
        :type  nic_infos: :class:`list` of :class:`NicInfo` or ``None``
        :param nic_infos: Set of information of a VM on the network interfaces present on the
            partner appliance that needs to be configured by the NSX Manager.
        """
        self.nic_infos = nic_infos
        VapiStruct.__init__(self)


VmNicInfo._set_binding_type(type.StructType(
    'com.vmware.nsx.model.vm_nic_info', {
        'nic_infos': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'NicInfo'))),
    },
    VmNicInfo,
    False,
    None))



class VmToolsInfo(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "VmToolsInfo"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    VM_TYPE_EDGE = "EDGE"
    """


    """
    VM_TYPE_SERVICE = "SERVICE"
    """


    """
    VM_TYPE_REGULAR = "REGULAR"
    """


    """



    _canonical_to_pep_names = {
                            'external_id': 'external_id',
                            'file_agent_version': 'file_agent_version',
                            'host_local_id': 'host_local_id',
                            'network_agent_version': 'network_agent_version',
                            'source': 'source',
                            'tools_version': 'tools_version',
                            'vm_type': 'vm_type',
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_last_sync_time': 'last_sync_time',
                            'description': 'description',
                            'display_name': 'display_name',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            }

    def __init__(self,
                 external_id=None,
                 file_agent_version=None,
                 host_local_id=None,
                 network_agent_version=None,
                 source=None,
                 tools_version=None,
                 vm_type=None,
                 links=None,
                 schema=None,
                 self_=None,
                 last_sync_time=None,
                 description=None,
                 display_name=None,
                 resource_type='VmToolsInfo',
                 tags=None,
                ):
        """
        :type  external_id: :class:`str` or ``None``
        :param external_id: Current external id of this virtual machine in the system.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  file_agent_version: :class:`str` or ``None``
        :param file_agent_version: Version of file agent on the VM of a third party partner solution.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  host_local_id: :class:`str` or ``None``
        :param host_local_id: Id of the VM which is assigned locally by the host. It is the
            VM-moref on ESXi hosts, in other environments it is VM UUID.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  network_agent_version: :class:`str` or ``None``
        :param network_agent_version: Version of network agent on the VM of a third party partner
            solution.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  source: :class:`ResourceReference` or ``None``
        :param source: Reference of the Host or Public Cloud Gateway that reported the VM.
        :type  tools_version: :class:`str` or ``None``
        :param tools_version: Version of VMTools installed on the VM.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  vm_type: :class:`str` or ``None``
        :param vm_type: Possible values are: 
            
            * :attr:`VmToolsInfo.VM_TYPE_EDGE`
            * :attr:`VmToolsInfo.VM_TYPE_SERVICE`
            * :attr:`VmToolsInfo.VM_TYPE_REGULAR`
            
             Type of VM - Edge, Service or other.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  last_sync_time: :class:`long` or ``None``
        :param last_sync_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  resource_type: :class:`str`
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        """
        self.external_id = external_id
        self.file_agent_version = file_agent_version
        self.host_local_id = host_local_id
        self.network_agent_version = network_agent_version
        self.source = source
        self.tools_version = tools_version
        self.vm_type = vm_type
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.last_sync_time = last_sync_time
        self.description = description
        self.display_name = display_name
        self._resource_type = resource_type
        self.tags = tags
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

VmToolsInfo._set_binding_type(type.StructType(
    'com.vmware.nsx.model.vm_tools_info', {
        'external_id': type.OptionalType(type.StringType()),
        'file_agent_version': type.OptionalType(type.StringType()),
        'host_local_id': type.OptionalType(type.StringType()),
        'network_agent_version': type.OptionalType(type.StringType()),
        'source': type.OptionalType(type.ReferenceType(__name__, 'ResourceReference')),
        'tools_version': type.OptionalType(type.StringType()),
        'vm_type': type.OptionalType(type.StringType()),
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_last_sync_time': type.OptionalType(type.IntegerType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
    },
    VmToolsInfo,
    False,
    None))



class VmToolsInfoListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`VmToolsInfo` or ``None``
        :param results: VmToolsInfo list results.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


VmToolsInfoListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.vm_tools_info_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'VmToolsInfo'))),
    },
    VmToolsInfoListResult,
    False,
    None))



class VmknicNetwork(VapiStruct):
    """
    Mapping of all vmk interfaces to destination networks

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'destination_network': 'destination_network',
                            'device_name': 'device_name',
                            }

    def __init__(self,
                 destination_network=None,
                 device_name=None,
                ):
        """
        :type  destination_network: :class:`str` or ``None``
        :param destination_network: When migrating vmks to N-VDS/logical switches, the id is the
            logical switch id. When migrating out of N-VDS/logical switches,
            the id is the vSphere Switch portgroup name in a single vSphere
            Standard Switch (VSS), or distributed virtual portgroup name in a
            single distributed virtual switch (DVS).
        :type  device_name: :class:`str` or ``None``
        :param device_name: The vmk interface name, e.g., vmk0, vmk1; the id assigned by
            vCenter.
        """
        self.destination_network = destination_network
        self.device_name = device_name
        VapiStruct.__init__(self)


VmknicNetwork._set_binding_type(type.StructType(
    'com.vmware.nsx.model.vmknic_network', {
        'destination_network': type.OptionalType(type.StringType()),
        'device_name': type.OptionalType(type.StringType()),
    },
    VmknicNetwork,
    False,
    None))



class VniPool(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'ranges': 'ranges',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 ranges=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  ranges: :class:`list` of :class:`VniRange` or ``None``
        :param ranges: VNI range list results
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.ranges = ranges
        VapiStruct.__init__(self)


VniPool._set_binding_type(type.StructType(
    'com.vmware.nsx.model.vni_pool', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'ranges': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'VniRange'))),
    },
    VniPool,
    False,
    None))



class VniPoolListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`VniPool` or ``None``
        :param results: VNI pool list results
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


VniPoolListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.vni_pool_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'VniPool'))),
    },
    VniPoolListResult,
    False,
    None))



class VniRange(VapiStruct):
    """
    A range of virtual network identifiers (VNIs)

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'end': 'end',
                            'start': 'start',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 end=None,
                 start=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  end: :class:`long` or ``None``
        :param end: End value for vni range to be used for virtual networks format:
            int64
        :type  start: :class:`long` or ``None``
        :param start: Start value for vni range to be used for virtual networks format:
            int64
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.end = end
        self.start = start
        VapiStruct.__init__(self)


VniRange._set_binding_type(type.StructType(
    'com.vmware.nsx.model.vni_range', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'end': type.OptionalType(type.IntegerType()),
        'start': type.OptionalType(type.IntegerType()),
    },
    VniRange,
    False,
    None))



class VsphereClusterNodeVMDeploymentConfig(VapiStruct):
    """
    The Vsphere deployment configuration determines where to deploy the cluster
    node VM through a vCenter server. It contains settings that are applied
    during install time. If using DHCP, the following fields must be left unset
    - dns_servers, management_port_subnets, and default_gateway_addresses

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "VsphereClusterNodeVMDeploymentConfig"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    DISK_PROVISIONING_THIN = "THIN"
    """


    """
    DISK_PROVISIONING_LAZY_ZEROED_THICK = "LAZY_ZEROED_THICK"
    """


    """
    DISK_PROVISIONING_EAGER_ZEROED_THICK = "EAGER_ZEROED_THICK"
    """


    """



    _canonical_to_pep_names = {
                            'allow_ssh_root_login': 'allow_ssh_root_login',
                            'compute_id': 'compute_id',
                            'default_gateway_addresses': 'default_gateway_addresses',
                            'disk_provisioning': 'disk_provisioning',
                            'dns_servers': 'dns_servers',
                            'enable_ssh': 'enable_ssh',
                            'host_id': 'host_id',
                            'hostname': 'hostname',
                            'management_network_id': 'management_network_id',
                            'management_port_subnets': 'management_port_subnets',
                            'ntp_servers': 'ntp_servers',
                            'search_domains': 'search_domains',
                            'storage_id': 'storage_id',
                            'vc_id': 'vc_id',
                            'placement_type': 'placement_type',
                            }

    def __init__(self,
                 allow_ssh_root_login=None,
                 compute_id=None,
                 default_gateway_addresses=None,
                 disk_provisioning=None,
                 dns_servers=None,
                 enable_ssh=None,
                 host_id=None,
                 hostname=None,
                 management_network_id=None,
                 management_port_subnets=None,
                 ntp_servers=None,
                 search_domains=None,
                 storage_id=None,
                 vc_id=None,
                 placement_type='VsphereClusterNodeVMDeploymentConfig',
                ):
        """
        :type  allow_ssh_root_login: :class:`bool` or ``None``
        :param allow_ssh_root_login: If true, the root user will be allowed to log into the VM. Allowing
            root SSH logins is not recommended for security reasons.
        :type  compute_id: :class:`str` or ``None``
        :param compute_id: The cluster node VM will be deployed on the specified cluster or
            resourcepool for specified VC server.
        :type  default_gateway_addresses: :class:`list` of :class:`str` or ``None``
        :param default_gateway_addresses: The default gateway for the VM to be deployed must be specified if
            all the other VMs it communicates with are not in the same subnet.
            Do not specify this field and management_port_subnets to use DHCP.
            Note: only single IPv4 default gateway address is supported and it
            must belong to management network. IMPORTANT: VMs deployed using
            DHCP are currently not supported, so this parameter should be
            specified. format: ip
        :type  disk_provisioning: :class:`str` or ``None``
        :param disk_provisioning: Possible values are: 
            
            *
              :attr:`VsphereClusterNodeVMDeploymentConfig.DISK_PROVISIONING_THIN`
            *
              :attr:`VsphereClusterNodeVMDeploymentConfig.DISK_PROVISIONING_LAZY_ZEROED_THICK`
            *
              :attr:`VsphereClusterNodeVMDeploymentConfig.DISK_PROVISIONING_EAGER_ZEROED_THICK`
            
             Specifies the disk provisioning type of the VM.
        :type  dns_servers: :class:`list` of :class:`str` or ``None``
        :param dns_servers: List of DNS servers. If DHCP is used, the default DNS servers
            associated with the DHCP server will be used instead. Required if
            using static IP. format: ipv4
        :type  enable_ssh: :class:`bool` or ``None``
        :param enable_ssh: If true, the SSH service will automatically be started on the VM.
            Enabling SSH service is not recommended for security reasons.
        :type  host_id: :class:`str` or ``None``
        :param host_id: The cluster node VM will be deployed on the specified host in the
            specified VC server within the cluster if host_id is specified.
            Note: User must ensure that storage and specified networks are
            accessible by this host.
        :type  hostname: :class:`str` or ``None``
        :param hostname: Desired host name/FQDN for the VM to be deployed
        :type  management_network_id: :class:`str` or ``None``
        :param management_network_id: Distributed portgroup identifier to which the management vnic of
            cluster node VM will be connected.
        :type  management_port_subnets: :class:`list` of :class:`IPSubnet` or ``None``
        :param management_port_subnets: IP Address and subnet configuration for the management port. Do not
            specify this field and default_gateway_addresses to use DHCP. Note:
            only one IPv4 address is supported for the management port.
            IMPORTANT: VMs deployed using DHCP are currently not supported, so
            this parameter should be specified.
        :type  ntp_servers: :class:`list` of :class:`str` or ``None``
        :param ntp_servers: List of NTP servers. To use hostnames, a DNS server must be
            defined. If not using DHCP, a DNS server should be specified under
            dns_servers. format: hostname-or-ipv4
        :type  search_domains: :class:`list` of :class:`str` or ``None``
        :param search_domains: List of domain names that are used to complete unqualified host
            names.
        :type  storage_id: :class:`str` or ``None``
        :param storage_id: The cluster node VM will be deployed on the specified datastore in
            the specified VC server. User must ensure that storage is
            accessible by the specified cluster/host.
        :type  vc_id: :class:`str` or ``None``
        :param vc_id: The VC-specific identifiers will be resolved on this VC, so all
            other identifiers specified in the config must belong to this
            vCenter server.
        :type  placement_type: :class:`str`
        :param placement_type: Possible values are: 
            
            *
              :attr:`ClusterNodeVMDeploymentConfig.PLACEMENT_TYPE_VSPHERECLUSTERNODEVMDEPLOYMENTCONFIG`
            
            Specifies the config for the platform through which to deploy the
            VM
        """
        self.allow_ssh_root_login = allow_ssh_root_login
        self.compute_id = compute_id
        self.default_gateway_addresses = default_gateway_addresses
        self.disk_provisioning = disk_provisioning
        self.dns_servers = dns_servers
        self.enable_ssh = enable_ssh
        self.host_id = host_id
        self.hostname = hostname
        self.management_network_id = management_network_id
        self.management_port_subnets = management_port_subnets
        self.ntp_servers = ntp_servers
        self.search_domains = search_domains
        self.storage_id = storage_id
        self.vc_id = vc_id
        self._placement_type = placement_type
        VapiStruct.__init__(self)

    @property
    def placement_type(self):
        """
        Return the discriminator value
        """
        return self._placement_type

VsphereClusterNodeVMDeploymentConfig._set_binding_type(type.StructType(
    'com.vmware.nsx.model.vsphere_cluster_node_VM_deployment_config', {
        'allow_ssh_root_login': type.OptionalType(type.BooleanType()),
        'compute_id': type.OptionalType(type.StringType()),
        'default_gateway_addresses': type.OptionalType(type.ListType(type.StringType())),
        'disk_provisioning': type.OptionalType(type.StringType()),
        'dns_servers': type.OptionalType(type.ListType(type.StringType())),
        'enable_ssh': type.OptionalType(type.BooleanType()),
        'host_id': type.OptionalType(type.StringType()),
        'hostname': type.OptionalType(type.StringType()),
        'management_network_id': type.OptionalType(type.StringType()),
        'management_port_subnets': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IPSubnet'))),
        'ntp_servers': type.OptionalType(type.ListType(type.StringType())),
        'search_domains': type.OptionalType(type.ListType(type.StringType())),
        'storage_id': type.OptionalType(type.StringType()),
        'vc_id': type.OptionalType(type.StringType()),
        'placement_type': type.StringType(),
    },
    VsphereClusterNodeVMDeploymentConfig,
    False,
    None))



class VsphereDeploymentConfig(VapiStruct):
    """
    The Vsphere deployment configuration determines where to deploy the edge
    node. It contains settings that are applied during install time. If using
    DHCP, you must leave the following fields unset: search_domains,
    management_port_subnets, dns_servers and default_gateway_addresses. Use
    EdgeNodeSettings to specify host name, SSH, NTP and DNS settings for both
    deployment and consequent update. These settings are editable for manually
    deployed edge nodes as well. EdgeNodeSettings reports current values
    configured on the edge node. The following fields are deprecated Hostname,
    SSH, NTP and DNS settings.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "VsphereDeploymentConfig"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'advanced_configuration': 'advanced_configuration',
                            'allow_ssh_root_login': 'allow_ssh_root_login',
                            'compute_id': 'compute_id',
                            'data_network_ids': 'data_network_ids',
                            'default_gateway_addresses': 'default_gateway_addresses',
                            'dns_servers': 'dns_servers',
                            'enable_ssh': 'enable_ssh',
                            'host_id': 'host_id',
                            'hostname': 'hostname',
                            'management_network_id': 'management_network_id',
                            'management_port_subnets': 'management_port_subnets',
                            'ntp_servers': 'ntp_servers',
                            'reservation_info': 'reservation_info',
                            'resource_allocation': 'resource_allocation',
                            'search_domains': 'search_domains',
                            'storage_id': 'storage_id',
                            'vc_id': 'vc_id',
                            'placement_type': 'placement_type',
                            }

    def __init__(self,
                 advanced_configuration=None,
                 allow_ssh_root_login=None,
                 compute_id=None,
                 data_network_ids=None,
                 default_gateway_addresses=None,
                 dns_servers=None,
                 enable_ssh=None,
                 host_id=None,
                 hostname=None,
                 management_network_id=None,
                 management_port_subnets=None,
                 ntp_servers=None,
                 reservation_info=None,
                 resource_allocation=None,
                 search_domains=None,
                 storage_id=None,
                 vc_id=None,
                 placement_type='VsphereDeploymentConfig',
                ):
        """
        :type  advanced_configuration: :class:`list` of :class:`KeyValuePair` or ``None``
        :param advanced_configuration: Array of additional specific properties for advanced or cloud-
            specific deployments in key-value format.
        :type  allow_ssh_root_login: :class:`bool` or ``None``
        :param allow_ssh_root_login: Allowing root SSH logins is not recommended for security reasons.
            This field is deprecated. Use allow_ssh_root_login property in
            EdgeNodeSettings section when creating transport nodes.
        :type  compute_id: :class:`str` or ``None``
        :param compute_id: The edge node vm will be deployed on the specified cluster or
            resourcepool. Note - all the hosts must have nsx fabric prepared in
            the specified cluster.
        :type  data_network_ids: :class:`list` of :class:`str` or ``None``
        :param data_network_ids: List of distributed portgroup or VLAN logical identifiers to which
            the datapath serving vnics of edge node vm will be connected.
        :type  default_gateway_addresses: :class:`list` of :class:`str` or ``None``
        :param default_gateway_addresses: The default gateway for edge node must be specified if all the
            nodes it communicates with are not in the same subnet. Note: Only
            single IPv4 default gateway address is supported and it must belong
            to management network. format: ip
        :type  dns_servers: :class:`list` of :class:`str` or ``None``
        :param dns_servers: List of DNS servers. This field is deprecated. Use dns_servers
            property in EdgeNodeSettings section when creating or updating
            transport nodes. format: ip
        :type  enable_ssh: :class:`bool` or ``None``
        :param enable_ssh: Enabling SSH service is not recommended for security reasons. This
            field is deprecated. Use enable_ssh property in EdgeNodeSettings
            section when creating or updating transport nodes.
        :type  host_id: :class:`str` or ``None``
        :param host_id: The edge node vm will be deployed on the specified Host within the
            cluster if host_id is specified. Note - User must ensure that
            storage and specified networks are accessible by this host.
        :type  hostname: :class:`str` or ``None``
        :param hostname: Host name or FQDN for edge node.
        :type  management_network_id: :class:`str` or ``None``
        :param management_network_id: Distributed portgroup identifier to which the management vnic of
            edge node vm will be connected. This portgroup must have
            connectivity with MP and CCP. A VLAN logical switch identifier may
            also be specified.
        :type  management_port_subnets: :class:`list` of :class:`IPSubnet` or ``None``
        :param management_port_subnets: IP Address and subnet configuration for the management port. Note:
            only one IPv4 address is supported for the management port.
        :type  ntp_servers: :class:`list` of :class:`str` or ``None``
        :param ntp_servers: List of NTP servers. This field is deprecated. Use ntp_servers
            property in EdgeNodeSettings section when creating or updating
            transport nodes. format: hostname-or-ipv4
        :type  reservation_info: :class:`ReservationInfo` or ``None``
        :param reservation_info: Resource reservation for memory and CPU resources.
        :type  resource_allocation: :class:`ResourceAssignment` or ``None``
        :param resource_allocation: Allocation for memory and CPU resources.
        :type  search_domains: :class:`list` of :class:`str` or ``None``
        :param search_domains: List of domain names that are used to complete unqualified host
            names. This field is deprecated. Use search_domains property in
            EdgeNodeSettings section when creating or updating transport nodes.
        :type  storage_id: :class:`str` or ``None``
        :param storage_id: The edge node vm will be deployed on the specified datastore. User
            must ensure that storage is accessible by the specified
            cluster/host.
        :type  vc_id: :class:`str` or ``None``
        :param vc_id: The vc specific identifiers will be resolved on this VC. So all
            other identifiers specified here must belong to this vcenter
            server.
        :type  placement_type: :class:`str`
        :param placement_type: Possible values are: 
            
            * :attr:`DeploymentConfig.PLACEMENT_TYPE_VSPHEREDEPLOYMENTCONFIG`
        """
        self.advanced_configuration = advanced_configuration
        self.allow_ssh_root_login = allow_ssh_root_login
        self.compute_id = compute_id
        self.data_network_ids = data_network_ids
        self.default_gateway_addresses = default_gateway_addresses
        self.dns_servers = dns_servers
        self.enable_ssh = enable_ssh
        self.host_id = host_id
        self.hostname = hostname
        self.management_network_id = management_network_id
        self.management_port_subnets = management_port_subnets
        self.ntp_servers = ntp_servers
        self.reservation_info = reservation_info
        self.resource_allocation = resource_allocation
        self.search_domains = search_domains
        self.storage_id = storage_id
        self.vc_id = vc_id
        self._placement_type = placement_type
        VapiStruct.__init__(self)

    @property
    def placement_type(self):
        """
        Return the discriminator value
        """
        return self._placement_type

VsphereDeploymentConfig._set_binding_type(type.StructType(
    'com.vmware.nsx.model.vsphere_deployment_config', {
        'advanced_configuration': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'KeyValuePair'))),
        'allow_ssh_root_login': type.OptionalType(type.BooleanType()),
        'compute_id': type.OptionalType(type.StringType()),
        'data_network_ids': type.OptionalType(type.ListType(type.StringType())),
        'default_gateway_addresses': type.OptionalType(type.ListType(type.StringType())),
        'dns_servers': type.OptionalType(type.ListType(type.StringType())),
        'enable_ssh': type.OptionalType(type.BooleanType()),
        'host_id': type.OptionalType(type.StringType()),
        'hostname': type.OptionalType(type.StringType()),
        'management_network_id': type.OptionalType(type.StringType()),
        'management_port_subnets': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'IPSubnet'))),
        'ntp_servers': type.OptionalType(type.ListType(type.StringType())),
        'reservation_info': type.OptionalType(type.ReferenceType(__name__, 'ReservationInfo')),
        'resource_allocation': type.OptionalType(type.ReferenceType(__name__, 'ResourceAssignment')),
        'search_domains': type.OptionalType(type.ListType(type.StringType())),
        'storage_id': type.OptionalType(type.StringType()),
        'vc_id': type.OptionalType(type.StringType()),
        'placement_type': type.StringType(),
    },
    VsphereDeploymentConfig,
    False,
    None))



class VtepCsvListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'file_name': 'file_name',
                            'last_update_timestamp': 'last_update_timestamp',
                            'results': 'results',
                            }

    def __init__(self,
                 file_name=None,
                 last_update_timestamp=None,
                 results=None,
                ):
        """
        :type  file_name: :class:`str` or ``None``
        :param file_name: File name set by HTTP server if API returns CSV result as a file.
        :type  last_update_timestamp: :class:`long` or ``None``
        :param last_update_timestamp: Timestamp when the data was last updated; unset if data source has
            never updated the data. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`VtepTableCsvRecord` or ``None``
        :param results: 
        """
        self.file_name = file_name
        self.last_update_timestamp = last_update_timestamp
        self.results = results
        VapiStruct.__init__(self)


VtepCsvListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.vtep_csv_list_result', {
        'file_name': type.OptionalType(type.StringType()),
        'last_update_timestamp': type.OptionalType(type.IntegerType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'VtepTableCsvRecord'))),
    },
    VtepCsvListResult,
    False,
    None))



class VtepLabelPool(VapiStruct):
    """
    A collection of ranges of virtual tunnel endpoint labels

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'pool_usage': 'pool_usage',
                            'ranges': 'ranges',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type=None,
                 tags=None,
                 pool_usage=None,
                 ranges=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Defaults to ID if not set
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str` or ``None``
        :param resource_type: The type of this resource.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  pool_usage: :class:`VtepLabelPoolUsage` or ``None``
        :param pool_usage: Pool usage statistics
        :type  ranges: :class:`list` of :class:`VtepLabelRange` or ``None``
        :param ranges: Array of ranges for virtual tunnel endpoint labels
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self.resource_type = resource_type
        self.tags = tags
        self.pool_usage = pool_usage
        self.ranges = ranges
        VapiStruct.__init__(self)


VtepLabelPool._set_binding_type(type.StructType(
    'com.vmware.nsx.model.vtep_label_pool', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.OptionalType(type.StringType()),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'pool_usage': type.OptionalType(type.ReferenceType(__name__, 'VtepLabelPoolUsage')),
        'ranges': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'VtepLabelRange'))),
    },
    VtepLabelPool,
    False,
    None))



class VtepLabelPoolListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'results': 'results',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 results=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`VtepLabelPool` or ``None``
        :param results: Virtual tunnel endpoint label pool list results
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.results = results
        VapiStruct.__init__(self)


VtepLabelPoolListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.vtep_label_pool_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'VtepLabelPool'))),
    },
    VtepLabelPoolListResult,
    False,
    None))



class VtepLabelPoolUsage(VapiStruct):
    """
    Pool usage statistics in a pool

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'allocated_ids': 'allocated_ids',
                            'free_ids': 'free_ids',
                            'total_ids': 'total_ids',
                            }

    def __init__(self,
                 allocated_ids=None,
                 free_ids=None,
                 total_ids=None,
                ):
        """
        :type  allocated_ids: :class:`long` or ``None``
        :param allocated_ids: Total number of allocated IDs in a pool format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  free_ids: :class:`long` or ``None``
        :param free_ids: Total number of free IDs in a pool format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  total_ids: :class:`long` or ``None``
        :param total_ids: Total number of IDs in a pool format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.allocated_ids = allocated_ids
        self.free_ids = free_ids
        self.total_ids = total_ids
        VapiStruct.__init__(self)


VtepLabelPoolUsage._set_binding_type(type.StructType(
    'com.vmware.nsx.model.vtep_label_pool_usage', {
        'allocated_ids': type.OptionalType(type.IntegerType()),
        'free_ids': type.OptionalType(type.IntegerType()),
        'total_ids': type.OptionalType(type.IntegerType()),
    },
    VtepLabelPoolUsage,
    False,
    None))



class VtepLabelRange(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'end': 'end',
                            'start': 'start',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 end=None,
                 start=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  end: :class:`long` or ``None``
        :param end: End value for virtual tunnel endpoint label range format: int64
        :type  start: :class:`long` or ``None``
        :param start: Start value for virtual tunnel endpoint label range format: int64
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.end = end
        self.start = start
        VapiStruct.__init__(self)


VtepLabelRange._set_binding_type(type.StructType(
    'com.vmware.nsx.model.vtep_label_range', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'end': type.OptionalType(type.IntegerType()),
        'start': type.OptionalType(type.IntegerType()),
    },
    VtepLabelRange,
    False,
    None))



class VtepListResult(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            'cursor': 'cursor',
                            'result_count': 'result_count',
                            'sort_ascending': 'sort_ascending',
                            'sort_by': 'sort_by',
                            'last_update_timestamp': 'last_update_timestamp',
                            'logical_switch_id': 'logical_switch_id',
                            'results': 'results',
                            'transport_node_id': 'transport_node_id',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 cursor=None,
                 result_count=None,
                 sort_ascending=None,
                 sort_by=None,
                 last_update_timestamp=None,
                 logical_switch_id=None,
                 results=None,
                 transport_node_id=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  result_count: :class:`long` or ``None``
        :param result_count: Count of results found (across all pages), set only on first page
            format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: If true, results are sorted in ascending order
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_update_timestamp: :class:`long` or ``None``
        :param last_update_timestamp: Timestamp when the data was last updated; unset if data source has
            never updated the data. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  logical_switch_id: :class:`str` or ``None``
        :param logical_switch_id: The id of the logical Switch
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  results: :class:`list` of :class:`VtepTableEntry` or ``None``
        :param results: 
        :type  transport_node_id: :class:`str` or ``None``
        :param transport_node_id: Transport node identifier
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.cursor = cursor
        self.result_count = result_count
        self.sort_ascending = sort_ascending
        self.sort_by = sort_by
        self.last_update_timestamp = last_update_timestamp
        self.logical_switch_id = logical_switch_id
        self.results = results
        self.transport_node_id = transport_node_id
        VapiStruct.__init__(self)


VtepListResult._set_binding_type(type.StructType(
    'com.vmware.nsx.model.vtep_list_result', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        'cursor': type.OptionalType(type.StringType()),
        'result_count': type.OptionalType(type.IntegerType()),
        'sort_ascending': type.OptionalType(type.BooleanType()),
        'sort_by': type.OptionalType(type.StringType()),
        'last_update_timestamp': type.OptionalType(type.IntegerType()),
        'logical_switch_id': type.OptionalType(type.StringType()),
        'results': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'VtepTableEntry'))),
        'transport_node_id': type.OptionalType(type.StringType()),
    },
    VtepListResult,
    False,
    None))



class VtepTableCsvRecord(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'segment_id': 'segment_id',
                            'vtep_ip': 'vtep_ip',
                            'vtep_label': 'vtep_label',
                            'vtep_mac_address': 'vtep_mac_address',
                            }

    def __init__(self,
                 segment_id=None,
                 vtep_ip=None,
                 vtep_label=None,
                 vtep_mac_address=None,
                ):
        """
        :type  segment_id: :class:`str` or ``None``
        :param segment_id: The segment Id
        :type  vtep_ip: :class:`str` or ``None``
        :param vtep_ip: The virtual tunnel endpoint IP address format: ip
        :type  vtep_label: :class:`long` or ``None``
        :param vtep_label: The virtual tunnel endpoint label format: int64
        :type  vtep_mac_address: :class:`str` or ``None``
        :param vtep_mac_address: The virtual tunnel endpoint MAC address
        """
        self.segment_id = segment_id
        self.vtep_ip = vtep_ip
        self.vtep_label = vtep_label
        self.vtep_mac_address = vtep_mac_address
        VapiStruct.__init__(self)


VtepTableCsvRecord._set_binding_type(type.StructType(
    'com.vmware.nsx.model.vtep_table_csv_record', {
        'segment_id': type.OptionalType(type.StringType()),
        'vtep_ip': type.OptionalType(type.StringType()),
        'vtep_label': type.OptionalType(type.IntegerType()),
        'vtep_mac_address': type.OptionalType(type.StringType()),
    },
    VtepTableCsvRecord,
    False,
    None))



class VtepTableEntry(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'segment_id': 'segment_id',
                            'vtep_ip': 'vtep_ip',
                            'vtep_label': 'vtep_label',
                            'vtep_mac_address': 'vtep_mac_address',
                            }

    def __init__(self,
                 segment_id=None,
                 vtep_ip=None,
                 vtep_label=None,
                 vtep_mac_address=None,
                ):
        """
        :type  segment_id: :class:`str` or ``None``
        :param segment_id: The segment Id
        :type  vtep_ip: :class:`str` or ``None``
        :param vtep_ip: The virtual tunnel endpoint IP address format: ip
        :type  vtep_label: :class:`long` or ``None``
        :param vtep_label: The virtual tunnel endpoint label format: int64
        :type  vtep_mac_address: :class:`str` or ``None``
        :param vtep_mac_address: The virtual tunnel endpoint MAC address
        """
        self.segment_id = segment_id
        self.vtep_ip = vtep_ip
        self.vtep_label = vtep_label
        self.vtep_mac_address = vtep_mac_address
        VapiStruct.__init__(self)


VtepTableEntry._set_binding_type(type.StructType(
    'com.vmware.nsx.model.vtep_table_entry', {
        'segment_id': type.OptionalType(type.StringType()),
        'vtep_ip': type.OptionalType(type.StringType()),
        'vtep_label': type.OptionalType(type.IntegerType()),
        'vtep_mac_address': type.OptionalType(type.StringType()),
    },
    VtepTableEntry,
    False,
    None))



class WeeklyBackupSchedule(VapiStruct):
    """
    Schedule to specify day of the week and time to take automated backup

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "WeeklyBackupSchedule"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """



    _canonical_to_pep_names = {
                            'days_of_week': 'days_of_week',
                            'hour_of_day': 'hour_of_day',
                            'minute_of_day': 'minute_of_day',
                            'resource_type': 'resource_type',
                            }

    def __init__(self,
                 days_of_week=None,
                 hour_of_day=None,
                 minute_of_day=None,
                 resource_type='WeeklyBackupSchedule',
                ):
        """
        :type  days_of_week: :class:`list` of :class:`long` or ``None``
        :param days_of_week: Days of week when backup is taken. 0 - Sunday, 1 - Monday, 2 -
            Tuesday, 3 - Wednesday ... format: int64
        :type  hour_of_day: :class:`long` or ``None``
        :param hour_of_day: Time of day when backup is taken format: int64
        :type  minute_of_day: :class:`long` or ``None``
        :param minute_of_day: Time of day when backup is taken format: int64
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`BackupSchedule.RESOURCE_TYPE_WEEKLYBACKUPSCHEDULE`
            * :attr:`BackupSchedule.RESOURCE_TYPE_INTERVALBACKUPSCHEDULE`
            
             Schedule type
        """
        self.days_of_week = days_of_week
        self.hour_of_day = hour_of_day
        self.minute_of_day = minute_of_day
        self._resource_type = resource_type
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

WeeklyBackupSchedule._set_binding_type(type.StructType(
    'com.vmware.nsx.model.weekly_backup_schedule', {
        'days_of_week': type.OptionalType(type.ListType(type.IntegerType())),
        'hour_of_day': type.OptionalType(type.IntegerType()),
        'minute_of_day': type.OptionalType(type.IntegerType()),
        'resource_type': type.StringType(),
    },
    WeeklyBackupSchedule,
    False,
    None))



class WeeklyTelemetrySchedule(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "WeeklyTelemetrySchedule"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    DAY_OF_WEEK_SUNDAY = "SUNDAY"
    """


    """
    DAY_OF_WEEK_MONDAY = "MONDAY"
    """


    """
    DAY_OF_WEEK_TUESDAY = "TUESDAY"
    """


    """
    DAY_OF_WEEK_WEDNESDAY = "WEDNESDAY"
    """


    """
    DAY_OF_WEEK_THURSDAY = "THURSDAY"
    """


    """
    DAY_OF_WEEK_FRIDAY = "FRIDAY"
    """


    """
    DAY_OF_WEEK_SATURDAY = "SATURDAY"
    """


    """



    _canonical_to_pep_names = {
                            'day_of_week': 'day_of_week',
                            'hour_of_day': 'hour_of_day',
                            'minutes': 'minutes',
                            'frequency_type': 'frequency_type',
                            }

    def __init__(self,
                 day_of_week=None,
                 hour_of_day=None,
                 minutes=None,
                 frequency_type='WeeklyTelemetrySchedule',
                ):
        """
        :type  day_of_week: :class:`str` or ``None``
        :param day_of_week: Possible values are: 
            
            * :attr:`WeeklyTelemetrySchedule.DAY_OF_WEEK_SUNDAY`
            * :attr:`WeeklyTelemetrySchedule.DAY_OF_WEEK_MONDAY`
            * :attr:`WeeklyTelemetrySchedule.DAY_OF_WEEK_TUESDAY`
            * :attr:`WeeklyTelemetrySchedule.DAY_OF_WEEK_WEDNESDAY`
            * :attr:`WeeklyTelemetrySchedule.DAY_OF_WEEK_THURSDAY`
            * :attr:`WeeklyTelemetrySchedule.DAY_OF_WEEK_FRIDAY`
            * :attr:`WeeklyTelemetrySchedule.DAY_OF_WEEK_SATURDAY`
            
            Day of week on which data will be collected. Specify one of SUNDAY
            through SATURDAY.
        :type  hour_of_day: :class:`long` or ``None``
        :param hour_of_day: Hour at which data will be collected. Specify a value between 0
            through 23. format: int64
        :type  minutes: :class:`long` or ``None``
        :param minutes: Minute at which data will be collected. Specify a value between 0
            through 59. format: int64
        :type  frequency_type: :class:`str`
        :param frequency_type: Specify one of DailyTelemetrySchedule, WeeklyTelemetrySchedule, or
            MonthlyTelemetrySchedule.
        """
        self.day_of_week = day_of_week
        self.hour_of_day = hour_of_day
        self.minutes = minutes
        self._frequency_type = frequency_type
        VapiStruct.__init__(self)

    @property
    def frequency_type(self):
        """
        Return the discriminator value
        """
        return self._frequency_type

WeeklyTelemetrySchedule._set_binding_type(type.StructType(
    'com.vmware.nsx.model.weekly_telemetry_schedule', {
        'day_of_week': type.OptionalType(type.StringType()),
        'hour_of_day': type.OptionalType(type.IntegerType()),
        'minutes': type.OptionalType(type.IntegerType()),
        'frequency_type': type.StringType(),
    },
    WeeklyTelemetrySchedule,
    False,
    None))



class WidgetConfiguration(VapiStruct):
    """
    Describes the configuration of a widget to be displayed on the dashboard.
    WidgetConfiguration is a base type that provides attributes of a widget
    in-general.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    _TYPE_IDENTIFIER = "WidgetConfiguration"
    """
    Identifier denoting this class, when it is used in polymorphic context. 

    This value should be assigned to the attribute which is used to discriminate
    the actual type used in the polymorphic context.

    """
    RESOURCE_TYPE_LABELVALUECONFIGURATION = "LabelValueConfiguration"
    """


    """
    RESOURCE_TYPE_DONUTCONFIGURATION = "DonutConfiguration"
    """


    """
    RESOURCE_TYPE_MULTIWIDGETCONFIGURATION = "MultiWidgetConfiguration"
    """


    """
    RESOURCE_TYPE_CONTAINERCONFIGURATION = "ContainerConfiguration"
    """


    """
    RESOURCE_TYPE_STATSCONFIGURATION = "StatsConfiguration"
    """


    """
    RESOURCE_TYPE_GRIDCONFIGURATION = "GridConfiguration"
    """


    """
    RESOURCE_TYPE_GRAPHCONFIGURATION = "GraphConfiguration"
    """


    """
    RESOURCE_TYPE_CUSTOMWIDGETCONFIGURATION = "CustomWidgetConfiguration"
    """


    """
    RESOURCE_TYPE_DROPDOWNFILTERWIDGETCONFIGURATION = "DropdownFilterWidgetConfiguration"
    """


    """



    _canonical_to_pep_names = {
                            '_links': 'links',
                            '_schema': 'schema',
                            '_self': 'self_',
                            '_revision': 'revision',
                            '_create_time': 'create_time',
                            '_create_user': 'create_user',
                            '_last_modified_time': 'last_modified_time',
                            '_last_modified_user': 'last_modified_user',
                            '_protection': 'protection',
                            '_system_owned': 'system_owned',
                            'description': 'description',
                            'display_name': 'display_name',
                            'id': 'id',
                            'resource_type': 'resource_type',
                            'tags': 'tags',
                            'datasources': 'datasources',
                            'default_filter_value': 'default_filter_value',
                            'drilldown_id': 'drilldown_id',
                            'filter': 'filter',
                            'filter_value_required': 'filter_value_required',
                            'footer': 'footer',
                            'icons': 'icons',
                            'is_drilldown': 'is_drilldown',
                            'legend': 'legend',
                            'shared': 'shared',
                            'span': 'span',
                            'weight': 'weight',
                            }

    def __init__(self,
                 links=None,
                 schema=None,
                 self_=None,
                 revision=None,
                 create_time=None,
                 create_user=None,
                 last_modified_time=None,
                 last_modified_user=None,
                 protection=None,
                 system_owned=None,
                 description=None,
                 display_name=None,
                 id=None,
                 resource_type='WidgetConfiguration',
                 tags=None,
                 datasources=None,
                 default_filter_value=None,
                 drilldown_id=None,
                 filter=None,
                 filter_value_required=None,
                 footer=None,
                 icons=None,
                 is_drilldown=None,
                 legend=None,
                 shared=None,
                 span=None,
                 weight=None,
                ):
        """
        :type  links: :class:`list` of :class:`ResourceLink` or ``None``
        :param links: The server will populate this field when returing the resource.
            Ignored on PUT and POST.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  schema: :class:`str` or ``None``
        :param schema: Schema for this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  self_: :class:`SelfResourceLink` or ``None``
        :param self_: Link to this resource
        :type  revision: :class:`long` or ``None``
        :param revision: The _revision property describes the current revision of the
            resource. To prevent clients from overwriting each other's changes,
            PUT operations must include the current _revision of the resource,
            which clients should obtain by issuing a GET operation. If the
            _revision provided in a PUT request is missing or stale, the
            operation will be rejected. format: int32
        :type  create_time: :class:`long` or ``None``
        :param create_time: Timestamp of resource creation format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  create_user: :class:`str` or ``None``
        :param create_user: ID of the user who created this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_time: :class:`long` or ``None``
        :param last_modified_time: Timestamp of last modification format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  last_modified_user: :class:`str` or ``None``
        :param last_modified_user: ID of the user who last modified this resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  protection: :class:`str` or ``None``
        :param protection: Protection status is one of the following: PROTECTED - the client
            who retrieved the entity is not allowed to modify it. NOT_PROTECTED
            - the client who retrieved the entity is allowed to modify it
            REQUIRE_OVERRIDE - the client who retrieved the entity is a super
            user and can modify it, but only when providing the request header
            X-Allow-Overwrite=true. UNKNOWN - the _protection field could not
            be determined for this entity.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  system_owned: :class:`bool` or ``None``
        :param system_owned: Indicates system owned resource
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  description: :class:`str` or ``None``
        :param description: Description of this resource
        :type  display_name: :class:`str` or ``None``
        :param display_name: Title of the widget. If display_name is omitted, the widget will be
            shown without a title.
        :type  id: :class:`str` or ``None``
        :param id: Unique identifier of this resource
        :type  resource_type: :class:`str`
        :param resource_type: Possible values are: 
            
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_LABELVALUECONFIGURATION`
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_DONUTCONFIGURATION`
            *
              :attr:`WidgetConfiguration.RESOURCE_TYPE_MULTIWIDGETCONFIGURATION`
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_CONTAINERCONFIGURATION`
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_STATSCONFIGURATION`
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_GRIDCONFIGURATION`
            * :attr:`WidgetConfiguration.RESOURCE_TYPE_GRAPHCONFIGURATION`
            *
              :attr:`WidgetConfiguration.RESOURCE_TYPE_CUSTOMWIDGETCONFIGURATION`
            *
              :attr:`WidgetConfiguration.RESOURCE_TYPE_DROPDOWNFILTERWIDGETCONFIGURATION`
            
            Supported visualization types are LabelValueConfiguration,
            DonutConfiguration, GridConfiguration, StatsConfiguration,
            MultiWidgetConfiguration, GraphConfiguration,
            ContainerConfiguration, CustomWidgetConfiguration and
            DropdownFilterWidgetConfiguration.
        :type  tags: :class:`list` of :class:`Tag` or ``None``
        :param tags: Opaque identifiers meaningful to the API user
        :type  datasources: :class:`list` of :class:`Datasource` or ``None``
        :param datasources: The 'datasources' represent the sources from which data will be
            fetched. Currently, only NSX-API is supported as a 'default'
            datasource. An example of specifying 'default' datasource along
            with the urls to fetch data from is given at 'example_request'
            section of 'CreateWidgetConfiguration' API.
        :type  default_filter_value: :class:`list` of :class:`DefaultFilterValue` or ``None``
        :param default_filter_value: Default filter values to be passed to datasources. This will be
            used when the report is requested without filter values.
        :type  drilldown_id: :class:`str` or ``None``
        :param drilldown_id: Id of drilldown widget, if any. Id should be a valid id of an
            existing widget. A widget is considered as drilldown widget when it
            is associated with any other widget and provides more detailed
            information about any data item from the parent widget.
        :type  filter: :class:`str` or ``None``
        :param filter: Id of filter widget for subscription, if any. Id should be a valid
            id of an existing filter widget. Filter widget should be from the
            same view. Datasource URLs should have placeholder values equal to
            filter alias to accept the filter value on filter change.
        :type  filter_value_required: :class:`bool` or ``None``
        :param filter_value_required: Flag to indicate that widget will continue to work without filter
            value. If this flag is set to false then default_filter_value is
            manadatory.
        :type  footer: :class:`Footer` or ``None``
        :param footer: 
        :type  icons: :class:`list` of :class:`Icon` or ``None``
        :param icons: Icons to be applied at dashboard for widgets and UI elements.
        :type  is_drilldown: :class:`bool` or ``None``
        :param is_drilldown: Set to true if this widget should be used as a drilldown.
        :type  legend: :class:`Legend` or ``None``
        :param legend: Legend to be displayed. If legend is not needed, do not include it.
        :type  shared: :class:`bool` or ``None``
        :param shared: Please use the property 'shared' of View instead of this. The
            widgets of a shared view are visible to other users.
        :type  span: :class:`long` or ``None``
        :param span: Represents the horizontal span of the widget / container. format:
            int32
        :type  weight: :class:`long` or ``None``
        :param weight: Specify relavite weight in WidgetItem for placement in a view.
            Please see WidgetItem for details. format: int32
        """
        self.links = links
        self.schema = schema
        self.self_ = self_
        self.revision = revision
        self.create_time = create_time
        self.create_user = create_user
        self.last_modified_time = last_modified_time
        self.last_modified_user = last_modified_user
        self.protection = protection
        self.system_owned = system_owned
        self.description = description
        self.display_name = display_name
        self.id = id
        self._resource_type = resource_type
        self.tags = tags
        self.datasources = datasources
        self.default_filter_value = default_filter_value
        self.drilldown_id = drilldown_id
        self.filter = filter
        self.filter_value_required = filter_value_required
        self.footer = footer
        self.icons = icons
        self.is_drilldown = is_drilldown
        self.legend = legend
        self.shared = shared
        self.span = span
        self.weight = weight
        VapiStruct.__init__(self)

    @property
    def resource_type(self):
        """
        Return the discriminator value
        """
        return self._resource_type

WidgetConfiguration._set_binding_type(type.StructType(
    'com.vmware.nsx.model.widget_configuration', {
        '_links': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'ResourceLink'))),
        '_schema': type.OptionalType(type.StringType()),
        '_self': type.OptionalType(type.ReferenceType(__name__, 'SelfResourceLink')),
        '_revision': type.OptionalType(type.IntegerType()),
        '_create_time': type.OptionalType(type.IntegerType()),
        '_create_user': type.OptionalType(type.StringType()),
        '_last_modified_time': type.OptionalType(type.IntegerType()),
        '_last_modified_user': type.OptionalType(type.StringType()),
        '_protection': type.OptionalType(type.StringType()),
        '_system_owned': type.OptionalType(type.BooleanType()),
        'description': type.OptionalType(type.StringType()),
        'display_name': type.OptionalType(type.StringType()),
        'id': type.OptionalType(type.StringType()),
        'resource_type': type.StringType(),
        'tags': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Tag'))),
        'datasources': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Datasource'))),
        'default_filter_value': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'DefaultFilterValue'))),
        'drilldown_id': type.OptionalType(type.StringType()),
        'filter': type.OptionalType(type.StringType()),
        'filter_value_required': type.OptionalType(type.BooleanType()),
        'footer': type.OptionalType(type.ReferenceType(__name__, 'Footer')),
        'icons': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'Icon'))),
        'is_drilldown': type.OptionalType(type.BooleanType()),
        'legend': type.OptionalType(type.ReferenceType(__name__, 'Legend')),
        'shared': type.OptionalType(type.BooleanType()),
        'span': type.OptionalType(type.IntegerType()),
        'weight': type.OptionalType(type.IntegerType()),
    },
    WidgetConfiguration,
    False,
    None))



class WidgetConfigurationList(VapiStruct):
    """
    Represents a list of widget configurations.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'widgetconfigurations': 'widgetconfigurations',
                            }

    def __init__(self,
                 widgetconfigurations=None,
                ):
        """
        :type  widgetconfigurations: :class:`list` of :class:`vmware.vapi.struct.VapiStruct` or ``None``
        :param widgetconfigurations: Array of widget configurations
            When clients pass a value of this class as a parameter, the
            attribute must contain all the attributes defined in
            :class:`WidgetConfiguration`. When methods return a value of this
            class as a return value, the attribute will contain all the
            attributes defined in :class:`WidgetConfiguration`.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.widgetconfigurations = widgetconfigurations
        VapiStruct.__init__(self)


WidgetConfigurationList._set_binding_type(type.StructType(
    'com.vmware.nsx.model.widget_configuration_list', {
        'widgetconfigurations': type.OptionalType(type.ListType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct, [type.ReferenceType(__name__, 'WidgetConfiguration')]))),
    },
    WidgetConfigurationList,
    False,
    None))



class WidgetItem(VapiStruct):
    """
    Represents a reference to a widget that is held by a container or a
    multi-widget or a View.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    ALIGNMENT_LEFT = "LEFT"
    """


    """
    ALIGNMENT_RIGHT = "RIGHT"
    """


    """



    _canonical_to_pep_names = {
                            'alignment': 'alignment',
                            'label': 'label',
                            'separator': 'separator',
                            'weight': 'weight',
                            'widget_id': 'widget_id',
                            }

    def __init__(self,
                 alignment=None,
                 label=None,
                 separator=None,
                 weight=None,
                 widget_id=None,
                ):
        """
        :type  alignment: :class:`str` or ``None``
        :param alignment: Possible values are: 
            
            * :attr:`WidgetItem.ALIGNMENT_LEFT`
            * :attr:`WidgetItem.ALIGNMENT_RIGHT`
            
             Aligns widget either left or right.
        :type  label: :class:`Label` or ``None``
        :param label: Applicable for 'DonutConfiguration' and 'StatsConfiguration'
            reports only. If label is not specified, then it defaults to the
            label of the donut or stats report.
        :type  separator: :class:`bool` or ``None``
        :param separator: If true, separates this widget in a container.
        :type  weight: :class:`long` or ``None``
        :param weight: Determines placement of widget or container relative to other
            widgets and containers. The lower the weight, the higher it is in
            the placement order. format: int32
        :type  widget_id: :class:`str` or ``None``
        :param widget_id: Id of the widget configuration that is held by a multi-widget or a
            container or a view.
        """
        self.alignment = alignment
        self.label = label
        self.separator = separator
        self.weight = weight
        self.widget_id = widget_id
        VapiStruct.__init__(self)


WidgetItem._set_binding_type(type.StructType(
    'com.vmware.nsx.model.widget_item', {
        'alignment': type.OptionalType(type.StringType()),
        'label': type.OptionalType(type.ReferenceType(__name__, 'Label')),
        'separator': type.OptionalType(type.BooleanType()),
        'weight': type.OptionalType(type.IntegerType()),
        'widget_id': type.OptionalType(type.StringType()),
    },
    WidgetItem,
    False,
    None))



class X509Certificate(VapiStruct):
    """


    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    ECDSA_EC_FIELD_F2M = "F2M"
    """


    """
    ECDSA_EC_FIELD_FP = "FP"
    """


    """
    PUBLIC_KEY_ALGO_RSA = "RSA"
    """


    """
    PUBLIC_KEY_ALGO_DSA = "DSA"
    """


    """
    PUBLIC_KEY_ALGO_ECDSA = "ECDSA"
    """


    """



    _canonical_to_pep_names = {
                            'dsa_public_key_g': 'dsa_public_keyg',
                            'dsa_public_key_p': 'dsa_public_keyp',
                            'dsa_public_key_q': 'dsa_public_keyq',
                            'dsa_public_key_y': 'dsa_public_keyy',
                            'ecdsa_curve_name': 'ecdsa_curve_name',
                            'ecdsa_ec_field': 'ecdsa_ec_field',
                            'ecdsa_ec_field_f2mks': 'ecdsa_ec_field_f2mks',
                            'ecdsa_ec_field_f2mm': 'ecdsa_ec_field_f2mm',
                            'ecdsa_ec_field_f2mrp': 'ecdsa_ec_field_f2mrp',
                            'ecdsa_ec_field_f2pp': 'ecdsa_ec_field_f2pp',
                            'ecdsa_public_key_a': 'ecdsa_public_keya',
                            'ecdsa_public_key_b': 'ecdsa_public_keyb',
                            'ecdsa_public_key_cofactor': 'ecdsa_public_key_cofactor',
                            'ecdsa_public_key_generator_x': 'ecdsa_public_key_generatorx',
                            'ecdsa_public_key_generator_y': 'ecdsa_public_key_generatory',
                            'ecdsa_public_key_order': 'ecdsa_public_key_order',
                            'ecdsa_public_key_seed': 'ecdsa_public_key_seed',
                            'is_ca': 'is_ca',
                            'is_valid': 'is_valid',
                            'issuer': 'issuer',
                            'issuer_cn': 'issuer_cn',
                            'not_after': 'not_after',
                            'not_before': 'not_before',
                            'public_key_algo': 'public_key_algo',
                            'public_key_length': 'public_key_length',
                            'rsa_public_key_exponent': 'rsa_public_key_exponent',
                            'rsa_public_key_modulus': 'rsa_public_key_modulus',
                            'serial_number': 'serial_number',
                            'signature': 'signature',
                            'signature_algorithm': 'signature_algorithm',
                            'subject': 'subject',
                            'subject_cn': 'subject_cn',
                            'version': 'version',
                            }

    def __init__(self,
                 dsa_public_keyg=None,
                 dsa_public_keyp=None,
                 dsa_public_keyq=None,
                 dsa_public_keyy=None,
                 ecdsa_curve_name=None,
                 ecdsa_ec_field=None,
                 ecdsa_ec_field_f2mks=None,
                 ecdsa_ec_field_f2mm=None,
                 ecdsa_ec_field_f2mrp=None,
                 ecdsa_ec_field_f2pp=None,
                 ecdsa_public_keya=None,
                 ecdsa_public_keyb=None,
                 ecdsa_public_key_cofactor=None,
                 ecdsa_public_key_generatorx=None,
                 ecdsa_public_key_generatory=None,
                 ecdsa_public_key_order=None,
                 ecdsa_public_key_seed=None,
                 is_ca=None,
                 is_valid=None,
                 issuer=None,
                 issuer_cn=None,
                 not_after=None,
                 not_before=None,
                 public_key_algo=None,
                 public_key_length=None,
                 rsa_public_key_exponent=None,
                 rsa_public_key_modulus=None,
                 serial_number=None,
                 signature=None,
                 signature_algorithm=None,
                 subject=None,
                 subject_cn=None,
                 version=None,
                ):
        """
        :type  dsa_public_keyg: :class:`str` or ``None``
        :param dsa_public_keyg: One of the DSA cryptogaphic algorithm's strength parameters, base.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  dsa_public_keyp: :class:`str` or ``None``
        :param dsa_public_keyp: One of the DSA cryptogaphic algorithm's strength parameters, prime.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  dsa_public_keyq: :class:`str` or ``None``
        :param dsa_public_keyq: One of the DSA cryptogaphic algorithm's strength parameters,
            sub-prime.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  dsa_public_keyy: :class:`str` or ``None``
        :param dsa_public_keyy: One of the DSA cryptogaphic algorithm's strength parameters.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  ecdsa_curve_name: :class:`str` or ``None``
        :param ecdsa_curve_name: The Curve name for the ECDSA certificate.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  ecdsa_ec_field: :class:`str` or ``None``
        :param ecdsa_ec_field: Possible values are: 
            
            * :attr:`X509Certificate.ECDSA_EC_FIELD_F2M`
            * :attr:`X509Certificate.ECDSA_EC_FIELD_FP`
            
             Represents an elliptic curve (EC) finite field in ECDSA.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  ecdsa_ec_field_f2mks: :class:`list` of :class:`long` or ``None``
        :param ecdsa_ec_field_f2mks: The order of the middle term(s) of the reduction polynomial in
            elliptic curve (EC) | characteristic 2 finite field.| Contents of
            this array are copied to protect against subsequent modification in
            ECDSA. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  ecdsa_ec_field_f2mm: :class:`long` or ``None``
        :param ecdsa_ec_field_f2mm: The first coefficient of this elliptic curve in elliptic curve (EC)
            | characteristic 2 finite field for ECDSA. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  ecdsa_ec_field_f2mrp: :class:`str` or ``None``
        :param ecdsa_ec_field_f2mrp: The value whose i-th bit corresponds to the i-th coefficient of the
            reduction polynomial | in elliptic curve (EC) characteristic 2
            finite field for ECDSA.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  ecdsa_ec_field_f2pp: :class:`str` or ``None``
        :param ecdsa_ec_field_f2pp: The specified prime for the elliptic curve prime finite field in
            ECDSA.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  ecdsa_public_keya: :class:`str` or ``None``
        :param ecdsa_public_keya: The first coefficient of this elliptic curve in ECDSA.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  ecdsa_public_keyb: :class:`str` or ``None``
        :param ecdsa_public_keyb: The second coefficient of this elliptic curve in ECDSA.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  ecdsa_public_key_cofactor: :class:`long` or ``None``
        :param ecdsa_public_key_cofactor: The co-factor in ECDSA. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  ecdsa_public_key_generatorx: :class:`str` or ``None``
        :param ecdsa_public_key_generatorx: X co-ordinate of G (the generator which is also known as the base
            point) in ECDSA.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  ecdsa_public_key_generatory: :class:`str` or ``None``
        :param ecdsa_public_key_generatory: Y co-ordinate of G (the generator which is also known as the base
            point) in ECDSA.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  ecdsa_public_key_order: :class:`str` or ``None``
        :param ecdsa_public_key_order: The order of generator G in ECDSA.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  ecdsa_public_key_seed: :class:`list` of :class:`str` or ``None``
        :param ecdsa_public_key_seed: The bytes used during curve generation for later validation in
            ECDSA.| Contents of this array are copied to protect against
            subsequent modification.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  is_ca: :class:`bool` or ``None``
        :param is_ca: True if this is a CA certificate.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  is_valid: :class:`bool` or ``None``
        :param is_valid: True if this certificate is valid.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  issuer: :class:`str` or ``None``
        :param issuer: The certificate issuers complete distinguished name.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  issuer_cn: :class:`str` or ``None``
        :param issuer_cn: The certificate issuer's common name.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  not_after: :class:`long` or ``None``
        :param not_after: The time in epoch milliseconds at which the certificate becomes
            invalid. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  not_before: :class:`long` or ``None``
        :param not_before: The time in epoch milliseconds at which the certificate becomes
            valid. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  public_key_algo: :class:`str` or ``None``
        :param public_key_algo: Possible values are: 
            
            * :attr:`X509Certificate.PUBLIC_KEY_ALGO_RSA`
            * :attr:`X509Certificate.PUBLIC_KEY_ALGO_DSA`
            * :attr:`X509Certificate.PUBLIC_KEY_ALGO_ECDSA`
            
            Cryptographic algorithm used by the public key for data encryption.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  public_key_length: :class:`long` or ``None``
        :param public_key_length: Size measured in bits of the public/private keys used in a
            cryptographic algorithm. format: int64
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  rsa_public_key_exponent: :class:`str` or ``None``
        :param rsa_public_key_exponent: An RSA public key is made up of the modulus and the public
            exponent. Exponent is a power number.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  rsa_public_key_modulus: :class:`str` or ``None``
        :param rsa_public_key_modulus: An RSA public key is made up of the modulus and the public
            exponent. Modulus is wrap around number.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  serial_number: :class:`str` or ``None``
        :param serial_number: Certificate's serial number.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  signature: :class:`str` or ``None``
        :param signature: The signature value(the raw signature bits) used for signing and
            validate the cert.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  signature_algorithm: :class:`str` or ``None``
        :param signature_algorithm: The algorithm used by the Certificate Authority to sign the
            certificate.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  subject: :class:`str` or ``None``
        :param subject: The certificate owners complete distinguished name.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  subject_cn: :class:`str` or ``None``
        :param subject_cn: The certificate owner's common name.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  version: :class:`str` or ``None``
        :param version: Certificate version (default v1).
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.dsa_public_keyg = dsa_public_keyg
        self.dsa_public_keyp = dsa_public_keyp
        self.dsa_public_keyq = dsa_public_keyq
        self.dsa_public_keyy = dsa_public_keyy
        self.ecdsa_curve_name = ecdsa_curve_name
        self.ecdsa_ec_field = ecdsa_ec_field
        self.ecdsa_ec_field_f2mks = ecdsa_ec_field_f2mks
        self.ecdsa_ec_field_f2mm = ecdsa_ec_field_f2mm
        self.ecdsa_ec_field_f2mrp = ecdsa_ec_field_f2mrp
        self.ecdsa_ec_field_f2pp = ecdsa_ec_field_f2pp
        self.ecdsa_public_keya = ecdsa_public_keya
        self.ecdsa_public_keyb = ecdsa_public_keyb
        self.ecdsa_public_key_cofactor = ecdsa_public_key_cofactor
        self.ecdsa_public_key_generatorx = ecdsa_public_key_generatorx
        self.ecdsa_public_key_generatory = ecdsa_public_key_generatory
        self.ecdsa_public_key_order = ecdsa_public_key_order
        self.ecdsa_public_key_seed = ecdsa_public_key_seed
        self.is_ca = is_ca
        self.is_valid = is_valid
        self.issuer = issuer
        self.issuer_cn = issuer_cn
        self.not_after = not_after
        self.not_before = not_before
        self.public_key_algo = public_key_algo
        self.public_key_length = public_key_length
        self.rsa_public_key_exponent = rsa_public_key_exponent
        self.rsa_public_key_modulus = rsa_public_key_modulus
        self.serial_number = serial_number
        self.signature = signature
        self.signature_algorithm = signature_algorithm
        self.subject = subject
        self.subject_cn = subject_cn
        self.version = version
        VapiStruct.__init__(self)


X509Certificate._set_binding_type(type.StructType(
    'com.vmware.nsx.model.x509_certificate', {
        'dsa_public_key_g': type.OptionalType(type.StringType()),
        'dsa_public_key_p': type.OptionalType(type.StringType()),
        'dsa_public_key_q': type.OptionalType(type.StringType()),
        'dsa_public_key_y': type.OptionalType(type.StringType()),
        'ecdsa_curve_name': type.OptionalType(type.StringType()),
        'ecdsa_ec_field': type.OptionalType(type.StringType()),
        'ecdsa_ec_field_f2mks': type.OptionalType(type.ListType(type.IntegerType())),
        'ecdsa_ec_field_f2mm': type.OptionalType(type.IntegerType()),
        'ecdsa_ec_field_f2mrp': type.OptionalType(type.StringType()),
        'ecdsa_ec_field_f2pp': type.OptionalType(type.StringType()),
        'ecdsa_public_key_a': type.OptionalType(type.StringType()),
        'ecdsa_public_key_b': type.OptionalType(type.StringType()),
        'ecdsa_public_key_cofactor': type.OptionalType(type.IntegerType()),
        'ecdsa_public_key_generator_x': type.OptionalType(type.StringType()),
        'ecdsa_public_key_generator_y': type.OptionalType(type.StringType()),
        'ecdsa_public_key_order': type.OptionalType(type.StringType()),
        'ecdsa_public_key_seed': type.OptionalType(type.ListType(type.StringType())),
        'is_ca': type.OptionalType(type.BooleanType()),
        'is_valid': type.OptionalType(type.BooleanType()),
        'issuer': type.OptionalType(type.StringType()),
        'issuer_cn': type.OptionalType(type.StringType()),
        'not_after': type.OptionalType(type.IntegerType()),
        'not_before': type.OptionalType(type.IntegerType()),
        'public_key_algo': type.OptionalType(type.StringType()),
        'public_key_length': type.OptionalType(type.IntegerType()),
        'rsa_public_key_exponent': type.OptionalType(type.StringType()),
        'rsa_public_key_modulus': type.OptionalType(type.StringType()),
        'serial_number': type.OptionalType(type.StringType()),
        'signature': type.OptionalType(type.StringType()),
        'signature_algorithm': type.OptionalType(type.StringType()),
        'subject': type.OptionalType(type.StringType()),
        'subject_cn': type.OptionalType(type.StringType()),
        'version': type.OptionalType(type.StringType()),
    },
    X509Certificate,
    False,
    None))



class X509Crl(VapiStruct):
    """
    A CRL is a time-stamped list identifying revoked certificates.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'crl_entries': 'crl_entries',
                            'issuer': 'issuer',
                            'next_update': 'next_update',
                            'version': 'version',
                            }

    def __init__(self,
                 crl_entries=None,
                 issuer=None,
                 next_update=None,
                 version=None,
                ):
        """
        :type  crl_entries: :class:`list` of :class:`X509CrlEntry` or ``None``
        :param crl_entries: List of X509CrlEntry.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  issuer: :class:`str` or ``None``
        :param issuer: Issuer's distinguished name. (DN)
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  next_update: :class:`str` or ``None``
        :param next_update: Next update time for the CRL.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  version: :class:`str` or ``None``
        :param version: CRL's version number either 1 or 2.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.crl_entries = crl_entries
        self.issuer = issuer
        self.next_update = next_update
        self.version = version
        VapiStruct.__init__(self)


X509Crl._set_binding_type(type.StructType(
    'com.vmware.nsx.model.x509_crl', {
        'crl_entries': type.OptionalType(type.ListType(type.ReferenceType(__name__, 'X509CrlEntry'))),
        'issuer': type.OptionalType(type.StringType()),
        'next_update': type.OptionalType(type.StringType()),
        'version': type.OptionalType(type.StringType()),
    },
    X509Crl,
    False,
    None))



class X509CrlEntry(VapiStruct):
    """
    Each revoked certificate is identified in a CRL by its certificate serial
    number.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """



    _canonical_to_pep_names = {
                            'revocation_date': 'revocation_date',
                            'serial_number': 'serial_number',
                            }

    def __init__(self,
                 revocation_date=None,
                 serial_number=None,
                ):
        """
        :type  revocation_date: :class:`str` or ``None``
        :param revocation_date: Revocation date.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        :type  serial_number: :class:`str` or ``None``
        :param serial_number: The revoked certificate's serial number.
            This attribute may be present in responses from the server, but if
            it is present in a request to server it will be ignored.
        """
        self.revocation_date = revocation_date
        self.serial_number = serial_number
        VapiStruct.__init__(self)


X509CrlEntry._set_binding_type(type.StructType(
    'com.vmware.nsx.model.x509_crl_entry', {
        'revocation_date': type.OptionalType(type.StringType()),
        'serial_number': type.OptionalType(type.StringType()),
    },
    X509CrlEntry,
    False,
    None))




class StubFactory(StubFactoryBase):
    _attrs = {
    }

