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

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

"""


"""

__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 DhcpRelayConfigs(VapiInterface):
    """
    
    """

    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.dhcp_relay_configs'
    """
    Identifier of the service in canonical form.
    """
    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _DhcpRelayConfigsStub)
        self._VAPI_OPERATION_IDS = {}


    def delete(self,
               dhcp_relay_config_id,
               ):
        """
        Delete DHCP relay configuration

        :type  dhcp_relay_config_id: :class:`str`
        :param dhcp_relay_config_id: DHCP relay config ID (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete',
                            {
                            'dhcp_relay_config_id': dhcp_relay_config_id,
                            })

    def get(self,
            dhcp_relay_config_id,
            ):
        """
        Read DHCP relay configuration

        :type  dhcp_relay_config_id: :class:`str`
        :param dhcp_relay_config_id: DHCP relay config ID (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.DhcpRelayConfig`
        :return: com.vmware.nsx_policy.model.DhcpRelayConfig
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get',
                            {
                            'dhcp_relay_config_id': dhcp_relay_config_id,
                            })

    def list(self,
             cursor=None,
             include_mark_for_delete_objects=None,
             included_fields=None,
             page_size=None,
             sort_ascending=None,
             sort_by=None,
             ):
        """
        Paginated list of all DHCP relay config instances

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.DhcpRelayConfigListResult`
        :return: com.vmware.nsx_policy.model.DhcpRelayConfigListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list',
                            {
                            'cursor': cursor,
                            'include_mark_for_delete_objects': include_mark_for_delete_objects,
                            'included_fields': included_fields,
                            'page_size': page_size,
                            'sort_ascending': sort_ascending,
                            'sort_by': sort_by,
                            })

    def patch(self,
              dhcp_relay_config_id,
              dhcp_relay_config,
              ):
        """
        If DHCP relay config with the dhcp-relay-config-id is not already
        present, create a new DHCP relay config instance. If it already exists,
        update the DHCP relay config instance with specified attributes.

        :type  dhcp_relay_config_id: :class:`str`
        :param dhcp_relay_config_id: DHCP relay config ID (required)
        :type  dhcp_relay_config: :class:`com.vmware.nsx_policy.model_client.DhcpRelayConfig`
        :param dhcp_relay_config: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch',
                            {
                            'dhcp_relay_config_id': dhcp_relay_config_id,
                            'dhcp_relay_config': dhcp_relay_config,
                            })

    def update(self,
               dhcp_relay_config_id,
               dhcp_relay_config,
               ):
        """
        If DHCP relay config with the dhcp-relay-config-id is not already
        present, create a new DHCP relay config instance. If it already exists,
        replace the DHCP relay config instance with this object.

        :type  dhcp_relay_config_id: :class:`str`
        :param dhcp_relay_config_id: DHCP relay config ID (required)
        :type  dhcp_relay_config: :class:`com.vmware.nsx_policy.model_client.DhcpRelayConfig`
        :param dhcp_relay_config: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.DhcpRelayConfig`
        :return: com.vmware.nsx_policy.model.DhcpRelayConfig
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update',
                            {
                            'dhcp_relay_config_id': dhcp_relay_config_id,
                            'dhcp_relay_config': dhcp_relay_config,
                            })
class DhcpServerConfigs(VapiInterface):
    """
    
    """

    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.dhcp_server_configs'
    """
    Identifier of the service in canonical form.
    """
    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _DhcpServerConfigsStub)
        self._VAPI_OPERATION_IDS = {}


    def delete(self,
               dhcp_server_config_id,
               ):
        """
        Delete DHCP server configuration

        :type  dhcp_server_config_id: :class:`str`
        :param dhcp_server_config_id: DHCP server config ID (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete',
                            {
                            'dhcp_server_config_id': dhcp_server_config_id,
                            })

    def get(self,
            dhcp_server_config_id,
            ):
        """
        Read DHCP server configuration

        :type  dhcp_server_config_id: :class:`str`
        :param dhcp_server_config_id: DHCP server config ID (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.DhcpServerConfig`
        :return: com.vmware.nsx_policy.model.DhcpServerConfig
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get',
                            {
                            'dhcp_server_config_id': dhcp_server_config_id,
                            })

    def list(self,
             cursor=None,
             include_mark_for_delete_objects=None,
             included_fields=None,
             page_size=None,
             sort_ascending=None,
             sort_by=None,
             ):
        """
        Paginated list of all DHCP server config instances

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.DhcpServerConfigListResult`
        :return: com.vmware.nsx_policy.model.DhcpServerConfigListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list',
                            {
                            'cursor': cursor,
                            'include_mark_for_delete_objects': include_mark_for_delete_objects,
                            'included_fields': included_fields,
                            'page_size': page_size,
                            'sort_ascending': sort_ascending,
                            'sort_by': sort_by,
                            })

    def patch(self,
              dhcp_server_config_id,
              dhcp_server_config,
              ):
        """
        If DHCP server config with the dhcp-server-config-id is not already
        present, create a new DHCP server config instance. If it already
        exists, update the DHCP server config instance with specified
        attributes. Realized entities of this API can be found using the path
        of Tier-0 that this config is applied on.

        :type  dhcp_server_config_id: :class:`str`
        :param dhcp_server_config_id: DHCP server config ID (required)
        :type  dhcp_server_config: :class:`com.vmware.nsx_policy.model_client.DhcpServerConfig`
        :param dhcp_server_config: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch',
                            {
                            'dhcp_server_config_id': dhcp_server_config_id,
                            'dhcp_server_config': dhcp_server_config,
                            })

    def update(self,
               dhcp_server_config_id,
               dhcp_server_config,
               ):
        """
        If DHCP server config with the dhcp-server-config-id is not already
        present, create a new DHCP server config instance. If it already
        exists, replace the DHCP server config instance with this object.
        Realized entities of this API can be found using the path of Tier-0
        that this config is applied on.

        :type  dhcp_server_config_id: :class:`str`
        :param dhcp_server_config_id: DHCP server config ID (required)
        :type  dhcp_server_config: :class:`com.vmware.nsx_policy.model_client.DhcpServerConfig`
        :param dhcp_server_config: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.DhcpServerConfig`
        :return: com.vmware.nsx_policy.model.DhcpServerConfig
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update',
                            {
                            'dhcp_server_config_id': dhcp_server_config_id,
                            'dhcp_server_config': dhcp_server_config,
                            })
class DnsForwarderZones(VapiInterface):
    """
    
    """

    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.dns_forwarder_zones'
    """
    Identifier of the service in canonical form.
    """
    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _DnsForwarderZonesStub)
        self._VAPI_OPERATION_IDS = {}


    def delete(self,
               dns_forwarder_zone_id,
               ):
        """
        Delete the DNS Forwarder Zone

        :type  dns_forwarder_zone_id: :class:`str`
        :param dns_forwarder_zone_id: DNS Forwarder Zone ID (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete',
                            {
                            'dns_forwarder_zone_id': dns_forwarder_zone_id,
                            })

    def get(self,
            dns_forwarder_zone_id,
            ):
        """
        Read the DNS Forwarder Zone

        :type  dns_forwarder_zone_id: :class:`str`
        :param dns_forwarder_zone_id: DNS Forwarder Zone ID (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.PolicyDnsForwarderZone`
        :return: com.vmware.nsx_policy.model.PolicyDnsForwarderZone
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get',
                            {
                            'dns_forwarder_zone_id': dns_forwarder_zone_id,
                            })

    def list(self,
             cursor=None,
             include_mark_for_delete_objects=None,
             included_fields=None,
             page_size=None,
             sort_ascending=None,
             sort_by=None,
             ):
        """
        Paginated list of all Dns Forwarder Zones

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.PolicyDnsForwarderZoneListResult`
        :return: com.vmware.nsx_policy.model.PolicyDnsForwarderZoneListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list',
                            {
                            'cursor': cursor,
                            'include_mark_for_delete_objects': include_mark_for_delete_objects,
                            'included_fields': included_fields,
                            'page_size': page_size,
                            'sort_ascending': sort_ascending,
                            'sort_by': sort_by,
                            })

    def patch(self,
              dns_forwarder_zone_id,
              policy_dns_forwarder_zone,
              ):
        """
        Create or update the DNS Forwarder Zone

        :type  dns_forwarder_zone_id: :class:`str`
        :param dns_forwarder_zone_id: DNS Forwarder Zone ID (required)
        :type  policy_dns_forwarder_zone: :class:`com.vmware.nsx_policy.model_client.PolicyDnsForwarderZone`
        :param policy_dns_forwarder_zone: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch',
                            {
                            'dns_forwarder_zone_id': dns_forwarder_zone_id,
                            'policy_dns_forwarder_zone': policy_dns_forwarder_zone,
                            })

    def update(self,
               dns_forwarder_zone_id,
               policy_dns_forwarder_zone,
               ):
        """
        Create or update the DNS Forwarder Zone

        :type  dns_forwarder_zone_id: :class:`str`
        :param dns_forwarder_zone_id: DNS Forwarder Zone ID (required)
        :type  policy_dns_forwarder_zone: :class:`com.vmware.nsx_policy.model_client.PolicyDnsForwarderZone`
        :param policy_dns_forwarder_zone: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.PolicyDnsForwarderZone`
        :return: com.vmware.nsx_policy.model.PolicyDnsForwarderZone
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update',
                            {
                            'dns_forwarder_zone_id': dns_forwarder_zone_id,
                            'policy_dns_forwarder_zone': policy_dns_forwarder_zone,
                            })
class Domains(VapiInterface):
    """
    
    """

    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.domains'
    """
    Identifier of the service in canonical form.
    """
    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _DomainsStub)
        self._VAPI_OPERATION_IDS = {}


    def get(self,
            domain_id,
            ):
        """
        Read a domain.

        :type  domain_id: :class:`str`
        :param domain_id: Domain ID (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.Domain`
        :return: com.vmware.nsx_policy.model.Domain
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get',
                            {
                            'domain_id': domain_id,
                            })

    def list(self,
             cursor=None,
             include_mark_for_delete_objects=None,
             included_fields=None,
             page_size=None,
             sort_ascending=None,
             sort_by=None,
             ):
        """
        Paginated list of all domains for infra.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.DomainListResult`
        :return: com.vmware.nsx_policy.model.DomainListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list',
                            {
                            'cursor': cursor,
                            'include_mark_for_delete_objects': include_mark_for_delete_objects,
                            'included_fields': included_fields,
                            'page_size': page_size,
                            'sort_ascending': sort_ascending,
                            'sort_by': sort_by,
                            })
class Drafts(VapiInterface):
    """
    
    """

    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.drafts'
    """
    Identifier of the service in canonical form.
    """
    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _DraftsStub)
        self._VAPI_OPERATION_IDS = {}


    def abort(self,
              draft_id,
              ):
        """
        If there is a failure during publish, the admin can choose to abort the
        publishing attempts. This will bring back the system to the current
        configuration, i.e just before the publish was invoked. If draft
        publishing is not in progress or already completed, then this is a
        NO-OP

        :type  draft_id: :class:`str`
        :param draft_id: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('abort',
                            {
                            'draft_id': draft_id,
                            })

    def delete(self,
               draft_id,
               ):
        """
        Delete a manual draft.

        :type  draft_id: :class:`str`
        :param draft_id: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete',
                            {
                            'draft_id': draft_id,
                            })

    def get(self,
            draft_id,
            ):
        """
        Read a draft for a given draft identifier.

        :type  draft_id: :class:`str`
        :param draft_id: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.PolicyDraft`
        :return: com.vmware.nsx_policy.model.PolicyDraft
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get',
                            {
                            'draft_id': draft_id,
                            })

    def list(self,
             auto_drafts=None,
             cursor=None,
             include_mark_for_delete_objects=None,
             included_fields=None,
             page_size=None,
             sort_ascending=None,
             sort_by=None,
             ):
        """
        List policy drafts.

        :type  auto_drafts: :class:`bool` or ``None``
        :param auto_drafts: Fetch list of draft based on is_auto_draft flag (optional)
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.PolicyDraftListResult`
        :return: com.vmware.nsx_policy.model.PolicyDraftListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list',
                            {
                            'auto_drafts': auto_drafts,
                            'cursor': cursor,
                            'include_mark_for_delete_objects': include_mark_for_delete_objects,
                            'included_fields': included_fields,
                            'page_size': page_size,
                            'sort_ascending': sort_ascending,
                            'sort_by': sort_by,
                            })

    def patch(self,
              draft_id,
              policy_draft,
              ):
        """
        Create a new manual draft if the specified draft id does not correspond
        to an existing draft. Update the manual draft otherwise. Auto draft can
        not be updated.

        :type  draft_id: :class:`str`
        :param draft_id: (required)
        :type  policy_draft: :class:`com.vmware.nsx_policy.model_client.PolicyDraft`
        :param policy_draft: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch',
                            {
                            'draft_id': draft_id,
                            'policy_draft': policy_draft,
                            })

    def publish(self,
                draft_id,
                infra,
                ):
        """
        Read a draft and publish it by applying changes onto current
        configuration.

        :type  draft_id: :class:`str`
        :param draft_id: (required)
        :type  infra: :class:`com.vmware.nsx_policy.model_client.Infra`
        :param infra: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('publish',
                            {
                            'draft_id': draft_id,
                            'infra': infra,
                            })

    def update(self,
               draft_id,
               policy_draft,
               ):
        """
        Create a new manual draft if the specified draft id does not correspond
        to an existing draft. Update the manual draft otherwise. Auto draft can
        not be updated.

        :type  draft_id: :class:`str`
        :param draft_id: (required)
        :type  policy_draft: :class:`com.vmware.nsx_policy.model_client.PolicyDraft`
        :param policy_draft: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.PolicyDraft`
        :return: com.vmware.nsx_policy.model.PolicyDraft
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update',
                            {
                            'draft_id': draft_id,
                            'policy_draft': policy_draft,
                            })
class GroupAssociations(VapiInterface):
    """
    
    """

    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.group_associations'
    """
    Identifier of the service in canonical form.
    """
    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _GroupAssociationsStub)
        self._VAPI_OPERATION_IDS = {}


    def list(self,
             intent_path,
             cursor=None,
             enforcement_point_path=None,
             include_mark_for_delete_objects=None,
             included_fields=None,
             page_size=None,
             sort_ascending=None,
             sort_by=None,
             ):
        """
        Get policy groups for which the given object is a member.

        :type  intent_path: :class:`str`
        :param intent_path: String path of the intent object (required)
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  enforcement_point_path: :class:`str` or ``None``
        :param enforcement_point_path: String Path of the enforcement point (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.PolicyResourceReferenceForEPListResult`
        :return: com.vmware.nsx_policy.model.PolicyResourceReferenceForEPListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list',
                            {
                            'intent_path': intent_path,
                            'cursor': cursor,
                            'enforcement_point_path': enforcement_point_path,
                            'include_mark_for_delete_objects': include_mark_for_delete_objects,
                            'included_fields': included_fields,
                            'page_size': page_size,
                            'sort_ascending': sort_ascending,
                            'sort_by': sort_by,
                            })
class IpfixCollectorProfiles(VapiInterface):
    """
    
    """

    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.ipfix_collector_profiles'
    """
    Identifier of the service in canonical form.
    """
    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _IpfixCollectorProfilesStub)
        self._VAPI_OPERATION_IDS = {}


    def delete(self,
               ipfix_collector_profile_id,
               ):
        """
        API deletes IPFIX collector profile. Flow forwarding to collector will
        be stopped. This API is deprecated. Please use the following API:
        https://<policy-mgr>/policy/api/v1/infra/ipfix-l2-collector-profiles

        :type  ipfix_collector_profile_id: :class:`str`
        :param ipfix_collector_profile_id: IPFIX collector Profile id (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete',
                            {
                            'ipfix_collector_profile_id': ipfix_collector_profile_id,
                            })

    def get(self,
            ipfix_collector_profile_id,
            ):
        """
        API will return details of IPFIX collector profile. If profile does not
        exist, it will return 404. This API is deprecated. Please use the
        following API:
        https://<policy-mgr>/policy/api/v1/infra/ipfix-l2-collector-profiles

        :type  ipfix_collector_profile_id: :class:`str`
        :param ipfix_collector_profile_id: IPFIX collector profile id (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXCollectorProfile`
        :return: com.vmware.nsx_policy.model.IPFIXCollectorProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get',
                            {
                            'ipfix_collector_profile_id': ipfix_collector_profile_id,
                            })

    def list(self,
             cursor=None,
             include_mark_for_delete_objects=None,
             included_fields=None,
             page_size=None,
             sort_ascending=None,
             sort_by=None,
             ):
        """
        API will provide list of all IPFIX collector profiles and their
        details. This API is deprecated. Please use the following API:
        https://<policy-mgr>/policy/api/v1/infra/ipfix-l2-collector-profiles

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXCollectorProfileListResult`
        :return: com.vmware.nsx_policy.model.IPFIXCollectorProfileListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list',
                            {
                            'cursor': cursor,
                            'include_mark_for_delete_objects': include_mark_for_delete_objects,
                            'included_fields': included_fields,
                            'page_size': page_size,
                            'sort_ascending': sort_ascending,
                            'sort_by': sort_by,
                            })

    def patch(self,
              ipfix_collector_profile_id,
              i_pfix_collector_profile,
              ):
        """
        Create a new IPFIX collector profile if the IPFIX collector profile
        with given id does not already exist. If the IPFIX collector profile
        with the given id already exists, patch with the existing IPFIX
        collector profile. This API is deprecated. Please use the following
        API:
        https://<policy-mgr>/policy/api/v1/infra/ipfix-l2-collector-profiles

        :type  ipfix_collector_profile_id: :class:`str`
        :param ipfix_collector_profile_id: IPFIX collector profile id (required)
        :type  i_pfix_collector_profile: :class:`com.vmware.nsx_policy.model_client.IPFIXCollectorProfile`
        :param i_pfix_collector_profile: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch',
                            {
                            'ipfix_collector_profile_id': ipfix_collector_profile_id,
                            'i_pfix_collector_profile': i_pfix_collector_profile,
                            })

    def update(self,
               ipfix_collector_profile_id,
               i_pfix_collector_profile,
               ):
        """
        Create or Replace IPFIX collector profile. IPFIX data will be sent to
        IPFIX collector port. This API is deprecated. Please use the following
        API:
        https://<policy-mgr>/policy/api/v1/infra/ipfix-l2-collector-profiles

        :type  ipfix_collector_profile_id: :class:`str`
        :param ipfix_collector_profile_id: IPFIX collector profile id (required)
        :type  i_pfix_collector_profile: :class:`com.vmware.nsx_policy.model_client.IPFIXCollectorProfile`
        :param i_pfix_collector_profile: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXCollectorProfile`
        :return: com.vmware.nsx_policy.model.IPFIXCollectorProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update',
                            {
                            'ipfix_collector_profile_id': ipfix_collector_profile_id,
                            'i_pfix_collector_profile': i_pfix_collector_profile,
                            })
class IpfixDfwCollectorProfiles(VapiInterface):
    """
    
    """

    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.ipfix_dfw_collector_profiles'
    """
    Identifier of the service in canonical form.
    """
    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _IpfixDfwCollectorProfilesStub)
        self._VAPI_OPERATION_IDS = {}


    def delete(self,
               ipfix_dfw_collector_profile_id,
               ):
        """
        API deletes IPFIX dfw collector profile. Flow forwarding to collector
        will be stopped.

        :type  ipfix_dfw_collector_profile_id: :class:`str`
        :param ipfix_dfw_collector_profile_id: IPFIX dfw collector Profile id (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete',
                            {
                            'ipfix_dfw_collector_profile_id': ipfix_dfw_collector_profile_id,
                            })

    def get(self,
            ipfix_dfw_collector_profile_id,
            ):
        """
        API will return details of IPFIX dfw collector profile. If profile does
        not exist, it will return 404.

        :type  ipfix_dfw_collector_profile_id: :class:`str`
        :param ipfix_dfw_collector_profile_id: IPFIX dfw collector profile id (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXDFWCollectorProfile`
        :return: com.vmware.nsx_policy.model.IPFIXDFWCollectorProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get',
                            {
                            'ipfix_dfw_collector_profile_id': ipfix_dfw_collector_profile_id,
                            })

    def list(self,
             cursor=None,
             include_mark_for_delete_objects=None,
             included_fields=None,
             page_size=None,
             sort_ascending=None,
             sort_by=None,
             ):
        """
        API will provide list of all IPFIX dfw collector profiles and their
        details.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXDFWCollectorProfileListResult`
        :return: com.vmware.nsx_policy.model.IPFIXDFWCollectorProfileListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list',
                            {
                            'cursor': cursor,
                            'include_mark_for_delete_objects': include_mark_for_delete_objects,
                            'included_fields': included_fields,
                            'page_size': page_size,
                            'sort_ascending': sort_ascending,
                            'sort_by': sort_by,
                            })

    def patch(self,
              ipfix_dfw_collector_profile_id,
              i_pfixdfw_collector_profile,
              ):
        """
        Create a new IPFIX dfw collector profile if the IPFIX dfw collector
        profile with given id does not already exist. If the IPFIX dfw
        collector profile with the given id already exists, patch with the
        existing IPFIX dfw collector profile.

        :type  ipfix_dfw_collector_profile_id: :class:`str`
        :param ipfix_dfw_collector_profile_id: (required)
        :type  i_pfixdfw_collector_profile: :class:`com.vmware.nsx_policy.model_client.IPFIXDFWCollectorProfile`
        :param i_pfixdfw_collector_profile: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch',
                            {
                            'ipfix_dfw_collector_profile_id': ipfix_dfw_collector_profile_id,
                            'i_pfixdfw_collector_profile': i_pfixdfw_collector_profile,
                            })

    def update(self,
               ipfix_dfw_collector_profile_id,
               i_pfixdfw_collector_profile,
               ):
        """
        Create or Replace IPFIX dfw collector profile. IPFIX data will be sent
        to IPFIX collector port.

        :type  ipfix_dfw_collector_profile_id: :class:`str`
        :param ipfix_dfw_collector_profile_id: IPFIX dfw collector profile id (required)
        :type  i_pfixdfw_collector_profile: :class:`com.vmware.nsx_policy.model_client.IPFIXDFWCollectorProfile`
        :param i_pfixdfw_collector_profile: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXDFWCollectorProfile`
        :return: com.vmware.nsx_policy.model.IPFIXDFWCollectorProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update',
                            {
                            'ipfix_dfw_collector_profile_id': ipfix_dfw_collector_profile_id,
                            'i_pfixdfw_collector_profile': i_pfixdfw_collector_profile,
                            })
class IpfixDfwProfiles(VapiInterface):
    """
    
    """

    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.ipfix_dfw_profiles'
    """
    Identifier of the service in canonical form.
    """
    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _IpfixDfwProfilesStub)
        self._VAPI_OPERATION_IDS = {}


    def delete(self,
               ipfix_dfw_profile_id,
               ):
        """
        API deletes IPFIX DFW Profile. Selected IPFIX Collectors will stop
        receiving flows.

        :type  ipfix_dfw_profile_id: :class:`str`
        :param ipfix_dfw_profile_id: IPFIX DFW Profile ID (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete',
                            {
                            'ipfix_dfw_profile_id': ipfix_dfw_profile_id,
                            })

    def get(self,
            ipfix_dfw_profile_id,
            ):
        """
        API will return details of IPFIX DFW profile.

        :type  ipfix_dfw_profile_id: :class:`str`
        :param ipfix_dfw_profile_id: IPFIX DFW collection id (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXDFWProfile`
        :return: com.vmware.nsx_policy.model.IPFIXDFWProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get',
                            {
                            'ipfix_dfw_profile_id': ipfix_dfw_profile_id,
                            })

    def list(self,
             cursor=None,
             include_mark_for_delete_objects=None,
             included_fields=None,
             page_size=None,
             sort_ascending=None,
             sort_by=None,
             ):
        """
        API provides list IPFIX DFW profiles available on selected logical DFW.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXDFWProfileListResult`
        :return: com.vmware.nsx_policy.model.IPFIXDFWProfileListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list',
                            {
                            'cursor': cursor,
                            'include_mark_for_delete_objects': include_mark_for_delete_objects,
                            'included_fields': included_fields,
                            'page_size': page_size,
                            'sort_ascending': sort_ascending,
                            'sort_by': sort_by,
                            })

    def patch(self,
              ipfix_dfw_profile_id,
              i_pfixdfw_profile,
              ):
        """
        Create a new IPFIX DFW profile if the IPFIX DFW profile with given id
        does not already exist. If the IPFIX DFW profile with the given id
        already exists, patch with the existing IPFIX DFW profile.

        :type  ipfix_dfw_profile_id: :class:`str`
        :param ipfix_dfw_profile_id: IPFIX DFW Profile ID (required)
        :type  i_pfixdfw_profile: :class:`com.vmware.nsx_policy.model_client.IPFIXDFWProfile`
        :param i_pfixdfw_profile: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch',
                            {
                            'ipfix_dfw_profile_id': ipfix_dfw_profile_id,
                            'i_pfixdfw_profile': i_pfixdfw_profile,
                            })

    def update(self,
               ipfix_dfw_profile_id,
               i_pfixdfw_profile,
               ):
        """
        Create or replace IPFIX DFW profile. Config will start forwarding data
        to provided IPFIX DFW collector.

        :type  ipfix_dfw_profile_id: :class:`str`
        :param ipfix_dfw_profile_id: IPFIX DFW Profile ID (required)
        :type  i_pfixdfw_profile: :class:`com.vmware.nsx_policy.model_client.IPFIXDFWProfile`
        :param i_pfixdfw_profile: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXDFWProfile`
        :return: com.vmware.nsx_policy.model.IPFIXDFWProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update',
                            {
                            'ipfix_dfw_profile_id': ipfix_dfw_profile_id,
                            'i_pfixdfw_profile': i_pfixdfw_profile,
                            })
class IpfixL2CollectorProfiles(VapiInterface):
    """
    
    """

    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.ipfix_l2_collector_profiles'
    """
    Identifier of the service in canonical form.
    """
    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _IpfixL2CollectorProfilesStub)
        self._VAPI_OPERATION_IDS = {}


    def delete(self,
               ipfix_l2_collector_profile_id,
               ):
        """
        API deletes IPFIX collector profile. Flow forwarding to collector will
        be stopped.

        :type  ipfix_l2_collector_profile_id: :class:`str`
        :param ipfix_l2_collector_profile_id: IPFIX collector Profile id (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete',
                            {
                            'ipfix_l2_collector_profile_id': ipfix_l2_collector_profile_id,
                            })

    def get(self,
            ipfix_l2_collector_profile_id,
            ):
        """
        API will return details of IPFIX collector profile.

        :type  ipfix_l2_collector_profile_id: :class:`str`
        :param ipfix_l2_collector_profile_id: IPFIX collector profile id (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXL2CollectorProfile`
        :return: com.vmware.nsx_policy.model.IPFIXL2CollectorProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get',
                            {
                            'ipfix_l2_collector_profile_id': ipfix_l2_collector_profile_id,
                            })

    def list(self,
             cursor=None,
             include_mark_for_delete_objects=None,
             included_fields=None,
             page_size=None,
             sort_ascending=None,
             sort_by=None,
             ):
        """
        API will provide list of all IPFIX collector profiles and their
        details.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXL2CollectorProfileListResult`
        :return: com.vmware.nsx_policy.model.IPFIXL2CollectorProfileListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list',
                            {
                            'cursor': cursor,
                            'include_mark_for_delete_objects': include_mark_for_delete_objects,
                            'included_fields': included_fields,
                            'page_size': page_size,
                            'sort_ascending': sort_ascending,
                            'sort_by': sort_by,
                            })

    def patch(self,
              ipfix_l2_collector_profile_id,
              i_pfix_l2_collector_profile,
              ):
        """
        Create a new IPFIX collector profile if the IPFIX collector profile
        with given id does not already exist. If the IPFIX collector profile
        with the given id already exists, patch with the existing IPFIX
        collector profile.

        :type  ipfix_l2_collector_profile_id: :class:`str`
        :param ipfix_l2_collector_profile_id: IPFIX collector profile id (required)
        :type  i_pfix_l2_collector_profile: :class:`com.vmware.nsx_policy.model_client.IPFIXL2CollectorProfile`
        :param i_pfix_l2_collector_profile: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch',
                            {
                            'ipfix_l2_collector_profile_id': ipfix_l2_collector_profile_id,
                            'i_pfix_l2_collector_profile': i_pfix_l2_collector_profile,
                            })

    def update(self,
               ipfix_l2_collector_profile_id,
               i_pfix_l2_collector_profile,
               ):
        """
        Create or Replace IPFIX collector profile. IPFIX data will be sent to
        IPFIX collector.

        :type  ipfix_l2_collector_profile_id: :class:`str`
        :param ipfix_l2_collector_profile_id: IPFIX collector profile id (required)
        :type  i_pfix_l2_collector_profile: :class:`com.vmware.nsx_policy.model_client.IPFIXL2CollectorProfile`
        :param i_pfix_l2_collector_profile: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXL2CollectorProfile`
        :return: com.vmware.nsx_policy.model.IPFIXL2CollectorProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update',
                            {
                            'ipfix_l2_collector_profile_id': ipfix_l2_collector_profile_id,
                            'i_pfix_l2_collector_profile': i_pfix_l2_collector_profile,
                            })
class IpfixL2Profiles(VapiInterface):
    """
    
    """

    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.ipfix_l2_profiles'
    """
    Identifier of the service in canonical form.
    """
    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _IpfixL2ProfilesStub)
        self._VAPI_OPERATION_IDS = {}


    def delete(self,
               ipfix_l2_profile_id,
               ):
        """
        API deletes IPFIX L2 Profile. Flow forwarding to selected collector
        will be stopped.

        :type  ipfix_l2_profile_id: :class:`str`
        :param ipfix_l2_profile_id: IPFIX L2 Profile ID (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete',
                            {
                            'ipfix_l2_profile_id': ipfix_l2_profile_id,
                            })

    def get(self,
            ipfix_l2_profile_id,
            ):
        """
        API will return details of IPFIX L2 profile.

        :type  ipfix_l2_profile_id: :class:`str`
        :param ipfix_l2_profile_id: IPFIX L2 profile id (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXL2Profile`
        :return: com.vmware.nsx_policy.model.IPFIXL2Profile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get',
                            {
                            'ipfix_l2_profile_id': ipfix_l2_profile_id,
                            })

    def list(self,
             cursor=None,
             include_mark_for_delete_objects=None,
             included_fields=None,
             page_size=None,
             sort_ascending=None,
             sort_by=None,
             ):
        """
        API provides list IPFIX L2 Profiles available on selected logical l2.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXL2ProfileListResult`
        :return: com.vmware.nsx_policy.model.IPFIXL2ProfileListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list',
                            {
                            'cursor': cursor,
                            'include_mark_for_delete_objects': include_mark_for_delete_objects,
                            'included_fields': included_fields,
                            'page_size': page_size,
                            'sort_ascending': sort_ascending,
                            'sort_by': sort_by,
                            })

    def patch(self,
              ipfix_l2_profile_id,
              i_pfix_l2_profile,
              ):
        """
        Create a new IPFIX L2 profile if the IPFIX L2 profile with given id
        does not already exist. If the IPFIX L2 profile with the given id
        already exists, patch with the existing IPFIX L2 profile.

        :type  ipfix_l2_profile_id: :class:`str`
        :param ipfix_l2_profile_id: IPFIX L2 Profile ID (required)
        :type  i_pfix_l2_profile: :class:`com.vmware.nsx_policy.model_client.IPFIXL2Profile`
        :param i_pfix_l2_profile: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch',
                            {
                            'ipfix_l2_profile_id': ipfix_l2_profile_id,
                            'i_pfix_l2_profile': i_pfix_l2_profile,
                            })

    def update(self,
               ipfix_l2_profile_id,
               i_pfix_l2_profile,
               ):
        """
        Create or replace IPFIX L2 Profile. Profile is reusable entity. Single
        profile can attached multiple bindings e.g group, segment and port.

        :type  ipfix_l2_profile_id: :class:`str`
        :param ipfix_l2_profile_id: IPFIX L2 Profile ID (required)
        :type  i_pfix_l2_profile: :class:`com.vmware.nsx_policy.model_client.IPFIXL2Profile`
        :param i_pfix_l2_profile: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXL2Profile`
        :return: com.vmware.nsx_policy.model.IPFIXL2Profile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update',
                            {
                            'ipfix_l2_profile_id': ipfix_l2_profile_id,
                            'i_pfix_l2_profile': i_pfix_l2_profile,
                            })
class IpsecVpnDpdProfiles(VapiInterface):
    """
    
    """

    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.ipsec_vpn_dpd_profiles'
    """
    Identifier of the service in canonical form.
    """
    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _IpsecVpnDpdProfilesStub)
        self._VAPI_OPERATION_IDS = {}


    def delete(self,
               dpd_profile_id,
               ):
        """
        Delete custom dead peer detection (DPD) profile. Profile can not be
        deleted if profile has references to it.

        :type  dpd_profile_id: :class:`str`
        :param dpd_profile_id: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete',
                            {
                            'dpd_profile_id': dpd_profile_id,
                            })

    def get(self,
            dpd_profile_id,
            ):
        """
        Get custom dead peer detection (DPD) profile, given the particular id.

        :type  dpd_profile_id: :class:`str`
        :param dpd_profile_id: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPSecVpnDpdProfile`
        :return: com.vmware.nsx_policy.model.IPSecVpnDpdProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get',
                            {
                            'dpd_profile_id': dpd_profile_id,
                            })

    def list(self,
             cursor=None,
             include_mark_for_delete_objects=None,
             included_fields=None,
             page_size=None,
             sort_ascending=None,
             sort_by=None,
             ):
        """
        Get paginated list of all DPD Profiles.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPSecVpnDpdProfileListResult`
        :return: com.vmware.nsx_policy.model.IPSecVpnDpdProfileListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list',
                            {
                            'cursor': cursor,
                            'include_mark_for_delete_objects': include_mark_for_delete_objects,
                            'included_fields': included_fields,
                            'page_size': page_size,
                            'sort_ascending': sort_ascending,
                            'sort_by': sort_by,
                            })

    def patch(self,
              dpd_profile_id,
              ip_sec_vpn_dpd_profile,
              ):
        """
        Create or patch dead peer detection (DPD) profile. Any change in
        profile affects all sessions consuming this profile. System will be
        provisioned with system owned editable default DPD profile. Any change
        in profile affects all sessions consuming this profile.

        :type  dpd_profile_id: :class:`str`
        :param dpd_profile_id: (required)
        :type  ip_sec_vpn_dpd_profile: :class:`com.vmware.nsx_policy.model_client.IPSecVpnDpdProfile`
        :param ip_sec_vpn_dpd_profile: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch',
                            {
                            'dpd_profile_id': dpd_profile_id,
                            'ip_sec_vpn_dpd_profile': ip_sec_vpn_dpd_profile,
                            })

    def update(self,
               dpd_profile_id,
               ip_sec_vpn_dpd_profile,
               ):
        """
        Create or patch dead peer detection (DPD) profile. Any change in
        profile affects all sessions consuming this profile. System will be
        provisioned with system owned editable default DPD profile. Any change
        in profile affects all sessions consuming this profile. Revision is
        optional for creation and required for update.

        :type  dpd_profile_id: :class:`str`
        :param dpd_profile_id: (required)
        :type  ip_sec_vpn_dpd_profile: :class:`com.vmware.nsx_policy.model_client.IPSecVpnDpdProfile`
        :param ip_sec_vpn_dpd_profile: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPSecVpnDpdProfile`
        :return: com.vmware.nsx_policy.model.IPSecVpnDpdProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update',
                            {
                            'dpd_profile_id': dpd_profile_id,
                            'ip_sec_vpn_dpd_profile': ip_sec_vpn_dpd_profile,
                            })
class IpsecVpnIkeProfiles(VapiInterface):
    """
    
    """

    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.ipsec_vpn_ike_profiles'
    """
    Identifier of the service in canonical form.
    """
    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _IpsecVpnIkeProfilesStub)
        self._VAPI_OPERATION_IDS = {}


    def delete(self,
               ike_profile_id,
               ):
        """
        Delete custom IKE Profile. Profile can not be deleted if profile has
        references to it.

        :type  ike_profile_id: :class:`str`
        :param ike_profile_id: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete',
                            {
                            'ike_profile_id': ike_profile_id,
                            })

    def get(self,
            ike_profile_id,
            ):
        """
        Get custom IKE Profile, given the particular id.

        :type  ike_profile_id: :class:`str`
        :param ike_profile_id: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPSecVpnIkeProfile`
        :return: com.vmware.nsx_policy.model.IPSecVpnIkeProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get',
                            {
                            'ike_profile_id': ike_profile_id,
                            })

    def list(self,
             cursor=None,
             include_mark_for_delete_objects=None,
             included_fields=None,
             page_size=None,
             sort_ascending=None,
             sort_by=None,
             ):
        """
        Get paginated list of all IKE Profiles.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPSecVpnIkeProfileListResult`
        :return: com.vmware.nsx_policy.model.IPSecVpnIkeProfileListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list',
                            {
                            'cursor': cursor,
                            'include_mark_for_delete_objects': include_mark_for_delete_objects,
                            'included_fields': included_fields,
                            'page_size': page_size,
                            'sort_ascending': sort_ascending,
                            'sort_by': sort_by,
                            })

    def patch(self,
              ike_profile_id,
              ip_sec_vpn_ike_profile,
              ):
        """
        Create or patch custom internet key exchange (IKE) Profile. IKE Profile
        is a reusable profile that captures IKE and phase one negotiation
        parameters. System will be pre provisioned with system owned editable
        default IKE profile and suggested set of profiles that can be used for
        peering with popular remote peers like AWS VPN. User can create custom
        profiles as needed. Any change in profile affects all sessions
        consuming this profile.

        :type  ike_profile_id: :class:`str`
        :param ike_profile_id: (required)
        :type  ip_sec_vpn_ike_profile: :class:`com.vmware.nsx_policy.model_client.IPSecVpnIkeProfile`
        :param ip_sec_vpn_ike_profile: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch',
                            {
                            'ike_profile_id': ike_profile_id,
                            'ip_sec_vpn_ike_profile': ip_sec_vpn_ike_profile,
                            })

    def update(self,
               ike_profile_id,
               ip_sec_vpn_ike_profile,
               ):
        """
        Create or fully replace custom internet key exchange (IKE) Profile. IKE
        Profile is a reusable profile that captures IKE and phase one
        negotiation parameters. System will be pre provisioned with system
        owned editable default IKE profile and suggested set of profiles that
        can be used for peering with popular remote peers like AWS VPN. User
        can create custom profiles as needed. Any change in profile affects all
        sessions consuming this profile. Revision is optional for creation and
        required for update.

        :type  ike_profile_id: :class:`str`
        :param ike_profile_id: (required)
        :type  ip_sec_vpn_ike_profile: :class:`com.vmware.nsx_policy.model_client.IPSecVpnIkeProfile`
        :param ip_sec_vpn_ike_profile: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPSecVpnIkeProfile`
        :return: com.vmware.nsx_policy.model.IPSecVpnIkeProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update',
                            {
                            'ike_profile_id': ike_profile_id,
                            'ip_sec_vpn_ike_profile': ip_sec_vpn_ike_profile,
                            })
class IpsecVpnTunnelProfiles(VapiInterface):
    """
    
    """

    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.ipsec_vpn_tunnel_profiles'
    """
    Identifier of the service in canonical form.
    """
    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _IpsecVpnTunnelProfilesStub)
        self._VAPI_OPERATION_IDS = {}


    def delete(self,
               tunnel_profile_id,
               ):
        """
        Delete custom IPSec tunnel Profile. Profile can not be deleted if
        profile has references to it.

        :type  tunnel_profile_id: :class:`str`
        :param tunnel_profile_id: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete',
                            {
                            'tunnel_profile_id': tunnel_profile_id,
                            })

    def get(self,
            tunnel_profile_id,
            ):
        """
        Get custom IPSec tunnel Profile, given the particular id.

        :type  tunnel_profile_id: :class:`str`
        :param tunnel_profile_id: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPSecVpnTunnelProfile`
        :return: com.vmware.nsx_policy.model.IPSecVpnTunnelProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get',
                            {
                            'tunnel_profile_id': tunnel_profile_id,
                            })

    def list(self,
             cursor=None,
             include_mark_for_delete_objects=None,
             included_fields=None,
             page_size=None,
             sort_ascending=None,
             sort_by=None,
             ):
        """
        Get paginated list of all IPSec tunnel Profiles.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPSecVpnTunnelProfileListResult`
        :return: com.vmware.nsx_policy.model.IPSecVpnTunnelProfileListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list',
                            {
                            'cursor': cursor,
                            'include_mark_for_delete_objects': include_mark_for_delete_objects,
                            'included_fields': included_fields,
                            'page_size': page_size,
                            'sort_ascending': sort_ascending,
                            'sort_by': sort_by,
                            })

    def patch(self,
              tunnel_profile_id,
              ip_sec_vpn_tunnel_profile,
              ):
        """
        Create or patch custom IPSec tunnel profile. IPSec tunnel profile is a
        reusable profile that captures phase two negotiation parameters and
        tunnel properties. System will be provisioned with system owned
        editable default IPSec tunnel profile. Any change in profile affects
        all sessions consuming this profile.

        :type  tunnel_profile_id: :class:`str`
        :param tunnel_profile_id: (required)
        :type  ip_sec_vpn_tunnel_profile: :class:`com.vmware.nsx_policy.model_client.IPSecVpnTunnelProfile`
        :param ip_sec_vpn_tunnel_profile: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch',
                            {
                            'tunnel_profile_id': tunnel_profile_id,
                            'ip_sec_vpn_tunnel_profile': ip_sec_vpn_tunnel_profile,
                            })

    def update(self,
               tunnel_profile_id,
               ip_sec_vpn_tunnel_profile,
               ):
        """
        Create or fully replace custom IPSec tunnel profile. IPSec tunnel
        profile is a reusable profile that captures phase two negotiation
        parameters and tunnel properties. System will be provisioned with
        system owned editable default IPSec tunnel profile. Any change in
        profile affects all sessions consuming this profile. Revision is
        optional for creation and required for update.

        :type  tunnel_profile_id: :class:`str`
        :param tunnel_profile_id: (required)
        :type  ip_sec_vpn_tunnel_profile: :class:`com.vmware.nsx_policy.model_client.IPSecVpnTunnelProfile`
        :param ip_sec_vpn_tunnel_profile: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPSecVpnTunnelProfile`
        :return: com.vmware.nsx_policy.model.IPSecVpnTunnelProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update',
                            {
                            'tunnel_profile_id': tunnel_profile_id,
                            'ip_sec_vpn_tunnel_profile': ip_sec_vpn_tunnel_profile,
                            })
class PartnerServices(VapiInterface):
    """
    
    """

    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.partner_services'
    """
    Identifier of the service in canonical form.
    """
    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _PartnerServicesStub)
        self._VAPI_OPERATION_IDS = {}


    def get(self,
            service_name,
            ):
        """
        Read the specific partner service identified by provided name.

        :type  service_name: :class:`str`
        :param service_name: Name of the service (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.ServiceDefinition`
        :return: com.vmware.nsx_policy.model.ServiceDefinition
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get',
                            {
                            'service_name': service_name,
                            })

    def list(self,
             cursor=None,
             include_mark_for_delete_objects=None,
             included_fields=None,
             page_size=None,
             sort_ascending=None,
             sort_by=None,
             ):
        """
        Read all the partner services available for service insertion

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.ServiceInsertionServiceListResult`
        :return: com.vmware.nsx_policy.model.ServiceInsertionServiceListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list',
                            {
                            'cursor': cursor,
                            'include_mark_for_delete_objects': include_mark_for_delete_objects,
                            'included_fields': included_fields,
                            'page_size': page_size,
                            'sort_ascending': sort_ascending,
                            'sort_by': sort_by,
                            })
class PortMirroringProfiles(VapiInterface):
    """
    
    """

    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.port_mirroring_profiles'
    """
    Identifier of the service in canonical form.
    """
    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _PortMirroringProfilesStub)
        self._VAPI_OPERATION_IDS = {}


    def delete(self,
               port_mirroring_profile_id,
               ):
        """
        API will delete port mirroring profile. Mirroring from source to
        destination ports will be stopped.

        :type  port_mirroring_profile_id: :class:`str`
        :param port_mirroring_profile_id: Port Mirroring Profile Id (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete',
                            {
                            'port_mirroring_profile_id': port_mirroring_profile_id,
                            })

    def get(self,
            port_mirroring_profile_id,
            ):
        """
        API will return details of port mirroring profile.

        :type  port_mirroring_profile_id: :class:`str`
        :param port_mirroring_profile_id: Port Mirroring Profile Id (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.PortMirroringProfile`
        :return: com.vmware.nsx_policy.model.PortMirroringProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get',
                            {
                            'port_mirroring_profile_id': port_mirroring_profile_id,
                            })

    def list(self,
             cursor=None,
             included_fields=None,
             page_size=None,
             sort_ascending=None,
             sort_by=None,
             ):
        """
        API will list all port mirroring profiles group.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.PortMirroringProfileListResult`
        :return: com.vmware.nsx_policy.model.PortMirroringProfileListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list',
                            {
                            'cursor': cursor,
                            'included_fields': included_fields,
                            'page_size': page_size,
                            'sort_ascending': sort_ascending,
                            'sort_by': sort_by,
                            })

    def patch(self,
              port_mirroring_profile_id,
              port_mirroring_profile,
              ):
        """
        Create a new Port Mirroring Profile if the Port Mirroring Profile with
        given id does not already exist. If the Port Mirroring Profile with the
        given id already exists, patch with the existing Port Mirroring
        Profile. Realized entities of this API can be found using the path of
        monitoring profile binding map that is used to apply this profile.

        :type  port_mirroring_profile_id: :class:`str`
        :param port_mirroring_profile_id: Port Mirroring Profile Id (required)
        :type  port_mirroring_profile: :class:`com.vmware.nsx_policy.model_client.PortMirroringProfile`
        :param port_mirroring_profile: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch',
                            {
                            'port_mirroring_profile_id': port_mirroring_profile_id,
                            'port_mirroring_profile': port_mirroring_profile,
                            })

    def update(self,
               port_mirroring_profile_id,
               port_mirroring_profile,
               ):
        """
        Create or Replace port mirroring profile. Packets will be mirrored from
        source group, segment, port to destination group. Realized entities of
        this API can be found using the path of monitoring profile binding map
        that is used to apply this profile.

        :type  port_mirroring_profile_id: :class:`str`
        :param port_mirroring_profile_id: Port Mirroring Profiles Id (required)
        :type  port_mirroring_profile: :class:`com.vmware.nsx_policy.model_client.PortMirroringProfile`
        :param port_mirroring_profile: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.PortMirroringProfile`
        :return: com.vmware.nsx_policy.model.PortMirroringProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update',
                            {
                            'port_mirroring_profile_id': port_mirroring_profile_id,
                            'port_mirroring_profile': port_mirroring_profile,
                            })
class Segments(VapiInterface):
    """
    
    """

    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.segments'
    """
    Identifier of the service in canonical form.
    """
    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _SegmentsStub)
        self._VAPI_OPERATION_IDS = {}


    def delete(self,
               segment_id,
               ):
        """
        Delete infra segment

        :type  segment_id: :class:`str`
        :param segment_id: Segment ID (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete',
                            {
                            'segment_id': segment_id,
                            })

    def delete_0(self,
                 segment_id,
                 ):
        """
        Force delete bypasses validations during segment deletion. This may
        result in an inconsistent connectivity.

        :type  segment_id: :class:`str`
        :param segment_id: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete_0',
                            {
                            'segment_id': segment_id,
                            })

    def get(self,
            segment_id,
            ):
        """
        Read infra segment

        :type  segment_id: :class:`str`
        :param segment_id: Segment ID (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.Segment`
        :return: com.vmware.nsx_policy.model.Segment
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get',
                            {
                            'segment_id': segment_id,
                            })

    def list(self,
             cursor=None,
             include_mark_for_delete_objects=None,
             included_fields=None,
             page_size=None,
             sort_ascending=None,
             sort_by=None,
             ):
        """
        Paginated list of all segments under infra.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.SegmentListResult`
        :return: com.vmware.nsx_policy.model.SegmentListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list',
                            {
                            'cursor': cursor,
                            'include_mark_for_delete_objects': include_mark_for_delete_objects,
                            'included_fields': included_fields,
                            'page_size': page_size,
                            'sort_ascending': sort_ascending,
                            'sort_by': sort_by,
                            })

    def patch(self,
              segment_id,
              segment,
              ):
        """
        If segment with the segment-id is not already present, create a new
        segment. If it already exists, update the segment with specified
        attributes.

        :type  segment_id: :class:`str`
        :param segment_id: Segment ID (required)
        :type  segment: :class:`com.vmware.nsx_policy.model_client.Segment`
        :param segment: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch',
                            {
                            'segment_id': segment_id,
                            'segment': segment,
                            })

    def update(self,
               segment_id,
               segment,
               ):
        """
        If segment with the segment-id is not already present, create a new
        segment. If it already exists, replace the segment with this object.

        :type  segment_id: :class:`str`
        :param segment_id: Segment ID (required)
        :type  segment: :class:`com.vmware.nsx_policy.model_client.Segment`
        :param segment: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.Segment`
        :return: com.vmware.nsx_policy.model.Segment
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update',
                            {
                            'segment_id': segment_id,
                            'segment': segment,
                            })
class Services(VapiInterface):
    """
    
    """

    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.services'
    """
    Identifier of the service in canonical form.
    """
    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _ServicesStub)
        self._VAPI_OPERATION_IDS = {}


    def delete(self,
               service_id,
               ):
        """
        Delete Service

        :type  service_id: :class:`str`
        :param service_id: Service ID (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete',
                            {
                            'service_id': service_id,
                            })

    def get(self,
            service_id,
            ):
        """
        Read a service

        :type  service_id: :class:`str`
        :param service_id: Service ID (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.Service`
        :return: com.vmware.nsx_policy.model.Service
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get',
                            {
                            'service_id': service_id,
                            })

    def list(self,
             cursor=None,
             default_service=None,
             include_mark_for_delete_objects=None,
             included_fields=None,
             page_size=None,
             sort_ascending=None,
             sort_by=None,
             ):
        """
        Paginated list of Services for infra.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  default_service: :class:`bool` or ``None``
        :param default_service: Fetch all default services (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.ServiceListResult`
        :return: com.vmware.nsx_policy.model.ServiceListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list',
                            {
                            'cursor': cursor,
                            'default_service': default_service,
                            'include_mark_for_delete_objects': include_mark_for_delete_objects,
                            'included_fields': included_fields,
                            'page_size': page_size,
                            'sort_ascending': sort_ascending,
                            'sort_by': sort_by,
                            })

    def patch(self,
              service_id,
              service,
              ):
        """
        Create a new service if a service with the given ID does not already
        exist. Creates new service entries if populated in the service. If a
        service with the given ID already exists, patch the service including
        the nested service entries.

        :type  service_id: :class:`str`
        :param service_id: Service ID (required)
        :type  service: :class:`com.vmware.nsx_policy.model_client.Service`
        :param service: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch',
                            {
                            'service_id': service_id,
                            'service': service,
                            })

    def update(self,
               service_id,
               service,
               ):
        """
        Create a new service if a service with the given ID does not already
        exist. Creates new service entries if populated in the service. If a
        service with the given ID already exists, update the service including
        the nested service entries. This is a full replace.

        :type  service_id: :class:`str`
        :param service_id: Service ID (required)
        :type  service: :class:`com.vmware.nsx_policy.model_client.Service`
        :param service: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.Service`
        :return: com.vmware.nsx_policy.model.Service
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update',
                            {
                            'service_id': service_id,
                            'service': service,
                            })
class _DhcpRelayConfigsStub(ApiInterfaceStub):
    def __init__(self, config):
        # properties for delete operation
        delete_input_type = type.StructType('operation-input', {
            'dhcp_relay_config_id': type.StringType(),
        })
        delete_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        delete_input_value_validator_list = [
        ]
        delete_output_validator_list = [
        ]
        delete_rest_metadata = OperationRestMetadata(
            http_method='DELETE',
            url_template='/policy/api/v1/infra/dhcp-relay-configs/{dhcp-relay-config-id}',
            path_variables={
                'dhcp_relay_config_id': 'dhcp-relay-config-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for get operation
        get_input_type = type.StructType('operation-input', {
            'dhcp_relay_config_id': type.StringType(),
        })
        get_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        get_input_value_validator_list = [
        ]
        get_output_validator_list = [
            HasFieldsOfValidator()
        ]
        get_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/dhcp-relay-configs/{dhcp-relay-config-id}',
            path_variables={
                'dhcp_relay_config_id': 'dhcp-relay-config-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for list operation
        list_input_type = type.StructType('operation-input', {
            'cursor': type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.BooleanType()),
            'included_fields': type.OptionalType(type.StringType()),
            'page_size': type.OptionalType(type.IntegerType()),
            'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType()),
        })
        list_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        list_input_value_validator_list = [
        ]
        list_output_validator_list = [
            HasFieldsOfValidator()
        ]
        list_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/dhcp-relay-configs',
            path_variables={
            },
            query_parameters={
                'cursor': 'cursor',
                'include_mark_for_delete_objects': 'include_mark_for_delete_objects',
                'included_fields': 'included_fields',
                'page_size': 'page_size',
                'sort_ascending': 'sort_ascending',
                'sort_by': 'sort_by',
            },
            content_type='application/json'
        )

        # properties for patch operation
        patch_input_type = type.StructType('operation-input', {
            'dhcp_relay_config_id': type.StringType(),
            'dhcp_relay_config': type.ReferenceType('com.vmware.nsx_policy.model_client', 'DhcpRelayConfig'),
        })
        patch_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        patch_input_value_validator_list = [
            HasFieldsOfValidator()
        ]
        patch_output_validator_list = [
        ]
        patch_rest_metadata = OperationRestMetadata(
            http_method='PATCH',
            url_template='/policy/api/v1/infra/dhcp-relay-configs/{dhcp-relay-config-id}',
            request_body_parameter='dhcp_relay_config',
            path_variables={
                'dhcp_relay_config_id': 'dhcp-relay-config-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for update operation
        update_input_type = type.StructType('operation-input', {
            'dhcp_relay_config_id': type.StringType(),
            'dhcp_relay_config': type.ReferenceType('com.vmware.nsx_policy.model_client', 'DhcpRelayConfig'),
        })
        update_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        update_input_value_validator_list = [
            HasFieldsOfValidator()
        ]
        update_output_validator_list = [
            HasFieldsOfValidator()
        ]
        update_rest_metadata = OperationRestMetadata(
            http_method='PUT',
            url_template='/policy/api/v1/infra/dhcp-relay-configs/{dhcp-relay-config-id}',
            request_body_parameter='dhcp_relay_config',
            path_variables={
                'dhcp_relay_config_id': 'dhcp-relay-config-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        operations = {
            'delete': {
                'input_type': delete_input_type,
                'output_type': type.VoidType(),
                'errors': delete_error_dict,
                'input_value_validator_list': delete_input_value_validator_list,
                'output_validator_list': delete_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'get': {
                'input_type': get_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'DhcpRelayConfig'),
                'errors': get_error_dict,
                'input_value_validator_list': get_input_value_validator_list,
                'output_validator_list': get_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'list': {
                'input_type': list_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'DhcpRelayConfigListResult'),
                'errors': list_error_dict,
                'input_value_validator_list': list_input_value_validator_list,
                'output_validator_list': list_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'patch': {
                'input_type': patch_input_type,
                'output_type': type.VoidType(),
                'errors': patch_error_dict,
                'input_value_validator_list': patch_input_value_validator_list,
                'output_validator_list': patch_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'update': {
                'input_type': update_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'DhcpRelayConfig'),
                'errors': update_error_dict,
                'input_value_validator_list': update_input_value_validator_list,
                'output_validator_list': update_output_validator_list,
                'task_type': TaskType.NONE,
            },
        }
        rest_metadata = {
            'delete': delete_rest_metadata,
            'get': get_rest_metadata,
            'list': list_rest_metadata,
            'patch': patch_rest_metadata,
            'update': update_rest_metadata,
        }
        ApiInterfaceStub.__init__(
            self, iface_name='com.vmware.nsx_policy.infra.dhcp_relay_configs',
            config=config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)

class _DhcpServerConfigsStub(ApiInterfaceStub):
    def __init__(self, config):
        # properties for delete operation
        delete_input_type = type.StructType('operation-input', {
            'dhcp_server_config_id': type.StringType(),
        })
        delete_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        delete_input_value_validator_list = [
        ]
        delete_output_validator_list = [
        ]
        delete_rest_metadata = OperationRestMetadata(
            http_method='DELETE',
            url_template='/policy/api/v1/infra/dhcp-server-configs/{dhcp-server-config-id}',
            path_variables={
                'dhcp_server_config_id': 'dhcp-server-config-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for get operation
        get_input_type = type.StructType('operation-input', {
            'dhcp_server_config_id': type.StringType(),
        })
        get_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        get_input_value_validator_list = [
        ]
        get_output_validator_list = [
            HasFieldsOfValidator()
        ]
        get_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/dhcp-server-configs/{dhcp-server-config-id}',
            path_variables={
                'dhcp_server_config_id': 'dhcp-server-config-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for list operation
        list_input_type = type.StructType('operation-input', {
            'cursor': type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.BooleanType()),
            'included_fields': type.OptionalType(type.StringType()),
            'page_size': type.OptionalType(type.IntegerType()),
            'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType()),
        })
        list_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        list_input_value_validator_list = [
        ]
        list_output_validator_list = [
            HasFieldsOfValidator()
        ]
        list_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/dhcp-server-configs',
            path_variables={
            },
            query_parameters={
                'cursor': 'cursor',
                'include_mark_for_delete_objects': 'include_mark_for_delete_objects',
                'included_fields': 'included_fields',
                'page_size': 'page_size',
                'sort_ascending': 'sort_ascending',
                'sort_by': 'sort_by',
            },
            content_type='application/json'
        )

        # properties for patch operation
        patch_input_type = type.StructType('operation-input', {
            'dhcp_server_config_id': type.StringType(),
            'dhcp_server_config': type.ReferenceType('com.vmware.nsx_policy.model_client', 'DhcpServerConfig'),
        })
        patch_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        patch_input_value_validator_list = [
            HasFieldsOfValidator()
        ]
        patch_output_validator_list = [
        ]
        patch_rest_metadata = OperationRestMetadata(
            http_method='PATCH',
            url_template='/policy/api/v1/infra/dhcp-server-configs/{dhcp-server-config-id}',
            request_body_parameter='dhcp_server_config',
            path_variables={
                'dhcp_server_config_id': 'dhcp-server-config-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for update operation
        update_input_type = type.StructType('operation-input', {
            'dhcp_server_config_id': type.StringType(),
            'dhcp_server_config': type.ReferenceType('com.vmware.nsx_policy.model_client', 'DhcpServerConfig'),
        })
        update_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        update_input_value_validator_list = [
            HasFieldsOfValidator()
        ]
        update_output_validator_list = [
            HasFieldsOfValidator()
        ]
        update_rest_metadata = OperationRestMetadata(
            http_method='PUT',
            url_template='/policy/api/v1/infra/dhcp-server-configs/{dhcp-server-config-id}',
            request_body_parameter='dhcp_server_config',
            path_variables={
                'dhcp_server_config_id': 'dhcp-server-config-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        operations = {
            'delete': {
                'input_type': delete_input_type,
                'output_type': type.VoidType(),
                'errors': delete_error_dict,
                'input_value_validator_list': delete_input_value_validator_list,
                'output_validator_list': delete_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'get': {
                'input_type': get_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'DhcpServerConfig'),
                'errors': get_error_dict,
                'input_value_validator_list': get_input_value_validator_list,
                'output_validator_list': get_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'list': {
                'input_type': list_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'DhcpServerConfigListResult'),
                'errors': list_error_dict,
                'input_value_validator_list': list_input_value_validator_list,
                'output_validator_list': list_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'patch': {
                'input_type': patch_input_type,
                'output_type': type.VoidType(),
                'errors': patch_error_dict,
                'input_value_validator_list': patch_input_value_validator_list,
                'output_validator_list': patch_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'update': {
                'input_type': update_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'DhcpServerConfig'),
                'errors': update_error_dict,
                'input_value_validator_list': update_input_value_validator_list,
                'output_validator_list': update_output_validator_list,
                'task_type': TaskType.NONE,
            },
        }
        rest_metadata = {
            'delete': delete_rest_metadata,
            'get': get_rest_metadata,
            'list': list_rest_metadata,
            'patch': patch_rest_metadata,
            'update': update_rest_metadata,
        }
        ApiInterfaceStub.__init__(
            self, iface_name='com.vmware.nsx_policy.infra.dhcp_server_configs',
            config=config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)

class _DnsForwarderZonesStub(ApiInterfaceStub):
    def __init__(self, config):
        # properties for delete operation
        delete_input_type = type.StructType('operation-input', {
            'dns_forwarder_zone_id': type.StringType(),
        })
        delete_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        delete_input_value_validator_list = [
        ]
        delete_output_validator_list = [
        ]
        delete_rest_metadata = OperationRestMetadata(
            http_method='DELETE',
            url_template='/policy/api/v1/infra/dns-forwarder-zones/{dns-forwarder-zone-id}',
            path_variables={
                'dns_forwarder_zone_id': 'dns-forwarder-zone-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for get operation
        get_input_type = type.StructType('operation-input', {
            'dns_forwarder_zone_id': type.StringType(),
        })
        get_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        get_input_value_validator_list = [
        ]
        get_output_validator_list = [
            HasFieldsOfValidator()
        ]
        get_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/dns-forwarder-zones/{dns-forwarder-zone-id}',
            path_variables={
                'dns_forwarder_zone_id': 'dns-forwarder-zone-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for list operation
        list_input_type = type.StructType('operation-input', {
            'cursor': type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.BooleanType()),
            'included_fields': type.OptionalType(type.StringType()),
            'page_size': type.OptionalType(type.IntegerType()),
            'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType()),
        })
        list_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        list_input_value_validator_list = [
        ]
        list_output_validator_list = [
            HasFieldsOfValidator()
        ]
        list_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/dns-forwarder-zones',
            path_variables={
            },
            query_parameters={
                'cursor': 'cursor',
                'include_mark_for_delete_objects': 'include_mark_for_delete_objects',
                'included_fields': 'included_fields',
                'page_size': 'page_size',
                'sort_ascending': 'sort_ascending',
                'sort_by': 'sort_by',
            },
            content_type='application/json'
        )

        # properties for patch operation
        patch_input_type = type.StructType('operation-input', {
            'dns_forwarder_zone_id': type.StringType(),
            'policy_dns_forwarder_zone': type.ReferenceType('com.vmware.nsx_policy.model_client', 'PolicyDnsForwarderZone'),
        })
        patch_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        patch_input_value_validator_list = [
            HasFieldsOfValidator()
        ]
        patch_output_validator_list = [
        ]
        patch_rest_metadata = OperationRestMetadata(
            http_method='PATCH',
            url_template='/policy/api/v1/infra/dns-forwarder-zones/{dns-forwarder-zone-id}',
            request_body_parameter='policy_dns_forwarder_zone',
            path_variables={
                'dns_forwarder_zone_id': 'dns-forwarder-zone-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for update operation
        update_input_type = type.StructType('operation-input', {
            'dns_forwarder_zone_id': type.StringType(),
            'policy_dns_forwarder_zone': type.ReferenceType('com.vmware.nsx_policy.model_client', 'PolicyDnsForwarderZone'),
        })
        update_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        update_input_value_validator_list = [
            HasFieldsOfValidator()
        ]
        update_output_validator_list = [
            HasFieldsOfValidator()
        ]
        update_rest_metadata = OperationRestMetadata(
            http_method='PUT',
            url_template='/policy/api/v1/infra/dns-forwarder-zones/{dns-forwarder-zone-id}',
            request_body_parameter='policy_dns_forwarder_zone',
            path_variables={
                'dns_forwarder_zone_id': 'dns-forwarder-zone-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        operations = {
            'delete': {
                'input_type': delete_input_type,
                'output_type': type.VoidType(),
                'errors': delete_error_dict,
                'input_value_validator_list': delete_input_value_validator_list,
                'output_validator_list': delete_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'get': {
                'input_type': get_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'PolicyDnsForwarderZone'),
                'errors': get_error_dict,
                'input_value_validator_list': get_input_value_validator_list,
                'output_validator_list': get_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'list': {
                'input_type': list_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'PolicyDnsForwarderZoneListResult'),
                'errors': list_error_dict,
                'input_value_validator_list': list_input_value_validator_list,
                'output_validator_list': list_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'patch': {
                'input_type': patch_input_type,
                'output_type': type.VoidType(),
                'errors': patch_error_dict,
                'input_value_validator_list': patch_input_value_validator_list,
                'output_validator_list': patch_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'update': {
                'input_type': update_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'PolicyDnsForwarderZone'),
                'errors': update_error_dict,
                'input_value_validator_list': update_input_value_validator_list,
                'output_validator_list': update_output_validator_list,
                'task_type': TaskType.NONE,
            },
        }
        rest_metadata = {
            'delete': delete_rest_metadata,
            'get': get_rest_metadata,
            'list': list_rest_metadata,
            'patch': patch_rest_metadata,
            'update': update_rest_metadata,
        }
        ApiInterfaceStub.__init__(
            self, iface_name='com.vmware.nsx_policy.infra.dns_forwarder_zones',
            config=config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)

class _DomainsStub(ApiInterfaceStub):
    def __init__(self, config):
        # properties for get operation
        get_input_type = type.StructType('operation-input', {
            'domain_id': type.StringType(),
        })
        get_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        get_input_value_validator_list = [
        ]
        get_output_validator_list = [
            HasFieldsOfValidator()
        ]
        get_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/domains/{domain-id}',
            path_variables={
                'domain_id': 'domain-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for list operation
        list_input_type = type.StructType('operation-input', {
            'cursor': type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.BooleanType()),
            'included_fields': type.OptionalType(type.StringType()),
            'page_size': type.OptionalType(type.IntegerType()),
            'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType()),
        })
        list_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        list_input_value_validator_list = [
        ]
        list_output_validator_list = [
            HasFieldsOfValidator()
        ]
        list_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/domains',
            path_variables={
            },
            query_parameters={
                'cursor': 'cursor',
                'include_mark_for_delete_objects': 'include_mark_for_delete_objects',
                'included_fields': 'included_fields',
                'page_size': 'page_size',
                'sort_ascending': 'sort_ascending',
                'sort_by': 'sort_by',
            },
            content_type='application/json'
        )

        operations = {
            'get': {
                'input_type': get_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'Domain'),
                'errors': get_error_dict,
                'input_value_validator_list': get_input_value_validator_list,
                'output_validator_list': get_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'list': {
                'input_type': list_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'DomainListResult'),
                'errors': list_error_dict,
                'input_value_validator_list': list_input_value_validator_list,
                'output_validator_list': list_output_validator_list,
                'task_type': TaskType.NONE,
            },
        }
        rest_metadata = {
            'get': get_rest_metadata,
            'list': list_rest_metadata,
        }
        ApiInterfaceStub.__init__(
            self, iface_name='com.vmware.nsx_policy.infra.domains',
            config=config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)

class _DraftsStub(ApiInterfaceStub):
    def __init__(self, config):
        # properties for abort operation
        abort_input_type = type.StructType('operation-input', {
            'draft_id': type.StringType(),
        })
        abort_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        abort_input_value_validator_list = [
        ]
        abort_output_validator_list = [
        ]
        abort_rest_metadata = OperationRestMetadata(
            http_method='POST',
            url_template='/policy/api/v1/infra/drafts/{draft-id}?action=abort',
            path_variables={
                'draft_id': 'draft-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for delete operation
        delete_input_type = type.StructType('operation-input', {
            'draft_id': type.StringType(),
        })
        delete_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        delete_input_value_validator_list = [
        ]
        delete_output_validator_list = [
        ]
        delete_rest_metadata = OperationRestMetadata(
            http_method='DELETE',
            url_template='/policy/api/v1/infra/drafts/{draft-id}',
            path_variables={
                'draft_id': 'draft-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for get operation
        get_input_type = type.StructType('operation-input', {
            'draft_id': type.StringType(),
        })
        get_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        get_input_value_validator_list = [
        ]
        get_output_validator_list = [
            HasFieldsOfValidator()
        ]
        get_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/drafts/{draft-id}',
            path_variables={
                'draft_id': 'draft-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for list operation
        list_input_type = type.StructType('operation-input', {
            'auto_drafts': type.OptionalType(type.BooleanType()),
            'cursor': type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.BooleanType()),
            'included_fields': type.OptionalType(type.StringType()),
            'page_size': type.OptionalType(type.IntegerType()),
            'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType()),
        })
        list_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        list_input_value_validator_list = [
        ]
        list_output_validator_list = [
            HasFieldsOfValidator()
        ]
        list_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/drafts',
            path_variables={
            },
            query_parameters={
                'auto_drafts': 'auto_drafts',
                'cursor': 'cursor',
                'include_mark_for_delete_objects': 'include_mark_for_delete_objects',
                'included_fields': 'included_fields',
                'page_size': 'page_size',
                'sort_ascending': 'sort_ascending',
                'sort_by': 'sort_by',
            },
            content_type='application/json'
        )

        # properties for patch operation
        patch_input_type = type.StructType('operation-input', {
            'draft_id': type.StringType(),
            'policy_draft': type.ReferenceType('com.vmware.nsx_policy.model_client', 'PolicyDraft'),
        })
        patch_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        patch_input_value_validator_list = [
            HasFieldsOfValidator()
        ]
        patch_output_validator_list = [
        ]
        patch_rest_metadata = OperationRestMetadata(
            http_method='PATCH',
            url_template='/policy/api/v1/infra/drafts/{draft-id}',
            request_body_parameter='policy_draft',
            path_variables={
                'draft_id': 'draft-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for publish operation
        publish_input_type = type.StructType('operation-input', {
            'draft_id': type.StringType(),
            'infra': type.ReferenceType('com.vmware.nsx_policy.model_client', 'Infra'),
        })
        publish_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        publish_input_value_validator_list = [
            HasFieldsOfValidator()
        ]
        publish_output_validator_list = [
        ]
        publish_rest_metadata = OperationRestMetadata(
            http_method='POST',
            url_template='/policy/api/v1/infra/drafts/{draft-id}?action=publish',
            request_body_parameter='infra',
            path_variables={
                'draft_id': 'draft-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for update operation
        update_input_type = type.StructType('operation-input', {
            'draft_id': type.StringType(),
            'policy_draft': type.ReferenceType('com.vmware.nsx_policy.model_client', 'PolicyDraft'),
        })
        update_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        update_input_value_validator_list = [
            HasFieldsOfValidator()
        ]
        update_output_validator_list = [
            HasFieldsOfValidator()
        ]
        update_rest_metadata = OperationRestMetadata(
            http_method='PUT',
            url_template='/policy/api/v1/infra/drafts/{draft-id}',
            request_body_parameter='policy_draft',
            path_variables={
                'draft_id': 'draft-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        operations = {
            'abort': {
                'input_type': abort_input_type,
                'output_type': type.VoidType(),
                'errors': abort_error_dict,
                'input_value_validator_list': abort_input_value_validator_list,
                'output_validator_list': abort_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'delete': {
                'input_type': delete_input_type,
                'output_type': type.VoidType(),
                'errors': delete_error_dict,
                'input_value_validator_list': delete_input_value_validator_list,
                'output_validator_list': delete_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'get': {
                'input_type': get_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'PolicyDraft'),
                'errors': get_error_dict,
                'input_value_validator_list': get_input_value_validator_list,
                'output_validator_list': get_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'list': {
                'input_type': list_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'PolicyDraftListResult'),
                'errors': list_error_dict,
                'input_value_validator_list': list_input_value_validator_list,
                'output_validator_list': list_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'patch': {
                'input_type': patch_input_type,
                'output_type': type.VoidType(),
                'errors': patch_error_dict,
                'input_value_validator_list': patch_input_value_validator_list,
                'output_validator_list': patch_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'publish': {
                'input_type': publish_input_type,
                'output_type': type.VoidType(),
                'errors': publish_error_dict,
                'input_value_validator_list': publish_input_value_validator_list,
                'output_validator_list': publish_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'update': {
                'input_type': update_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'PolicyDraft'),
                'errors': update_error_dict,
                'input_value_validator_list': update_input_value_validator_list,
                'output_validator_list': update_output_validator_list,
                'task_type': TaskType.NONE,
            },
        }
        rest_metadata = {
            'abort': abort_rest_metadata,
            'delete': delete_rest_metadata,
            'get': get_rest_metadata,
            'list': list_rest_metadata,
            'patch': patch_rest_metadata,
            'publish': publish_rest_metadata,
            'update': update_rest_metadata,
        }
        ApiInterfaceStub.__init__(
            self, iface_name='com.vmware.nsx_policy.infra.drafts',
            config=config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)

class _GroupAssociationsStub(ApiInterfaceStub):
    def __init__(self, config):
        # properties for list operation
        list_input_type = type.StructType('operation-input', {
            'intent_path': type.StringType(),
            'cursor': type.OptionalType(type.StringType()),
            'enforcement_point_path': type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.BooleanType()),
            'included_fields': type.OptionalType(type.StringType()),
            'page_size': type.OptionalType(type.IntegerType()),
            'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType()),
        })
        list_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        list_input_value_validator_list = [
        ]
        list_output_validator_list = [
        ]
        list_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/group-associations',
            path_variables={
            },
            query_parameters={
                'intent_path': 'intent_path',
                'cursor': 'cursor',
                'enforcement_point_path': 'enforcement_point_path',
                'include_mark_for_delete_objects': 'include_mark_for_delete_objects',
                'included_fields': 'included_fields',
                'page_size': 'page_size',
                'sort_ascending': 'sort_ascending',
                'sort_by': 'sort_by',
            },
            content_type='application/json'
        )

        operations = {
            'list': {
                'input_type': list_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'PolicyResourceReferenceForEPListResult'),
                'errors': list_error_dict,
                'input_value_validator_list': list_input_value_validator_list,
                'output_validator_list': list_output_validator_list,
                'task_type': TaskType.NONE,
            },
        }
        rest_metadata = {
            'list': list_rest_metadata,
        }
        ApiInterfaceStub.__init__(
            self, iface_name='com.vmware.nsx_policy.infra.group_associations',
            config=config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)

class _IpfixCollectorProfilesStub(ApiInterfaceStub):
    def __init__(self, config):
        # properties for delete operation
        delete_input_type = type.StructType('operation-input', {
            'ipfix_collector_profile_id': type.StringType(),
        })
        delete_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        delete_input_value_validator_list = [
        ]
        delete_output_validator_list = [
        ]
        delete_rest_metadata = OperationRestMetadata(
            http_method='DELETE',
            url_template='/policy/api/v1/infra/ipfix-collector-profiles/{ipfix-collector-profile-id}',
            path_variables={
                'ipfix_collector_profile_id': 'ipfix-collector-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for get operation
        get_input_type = type.StructType('operation-input', {
            'ipfix_collector_profile_id': type.StringType(),
        })
        get_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        get_input_value_validator_list = [
        ]
        get_output_validator_list = [
            HasFieldsOfValidator()
        ]
        get_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/ipfix-collector-profiles/{ipfix-collector-profile-id}',
            path_variables={
                'ipfix_collector_profile_id': 'ipfix-collector-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for list operation
        list_input_type = type.StructType('operation-input', {
            'cursor': type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.BooleanType()),
            'included_fields': type.OptionalType(type.StringType()),
            'page_size': type.OptionalType(type.IntegerType()),
            'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType()),
        })
        list_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        list_input_value_validator_list = [
        ]
        list_output_validator_list = [
            HasFieldsOfValidator()
        ]
        list_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/ipfix-collector-profiles',
            path_variables={
            },
            query_parameters={
                'cursor': 'cursor',
                'include_mark_for_delete_objects': 'include_mark_for_delete_objects',
                'included_fields': 'included_fields',
                'page_size': 'page_size',
                'sort_ascending': 'sort_ascending',
                'sort_by': 'sort_by',
            },
            content_type='application/json'
        )

        # properties for patch operation
        patch_input_type = type.StructType('operation-input', {
            'ipfix_collector_profile_id': type.StringType(),
            'i_PFIX_collector_profile': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPFIXCollectorProfile'),
        })
        patch_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        patch_input_value_validator_list = [
            HasFieldsOfValidator()
        ]
        patch_output_validator_list = [
        ]
        patch_rest_metadata = OperationRestMetadata(
            http_method='PATCH',
            url_template='/policy/api/v1/infra/ipfix-collector-profiles/{ipfix-collector-profile-id}',
            request_body_parameter='i_PFIX_collector_profile',
            path_variables={
                'ipfix_collector_profile_id': 'ipfix-collector-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for update operation
        update_input_type = type.StructType('operation-input', {
            'ipfix_collector_profile_id': type.StringType(),
            'i_PFIX_collector_profile': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPFIXCollectorProfile'),
        })
        update_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        update_input_value_validator_list = [
            HasFieldsOfValidator()
        ]
        update_output_validator_list = [
            HasFieldsOfValidator()
        ]
        update_rest_metadata = OperationRestMetadata(
            http_method='PUT',
            url_template='/policy/api/v1/infra/ipfix-collector-profiles/{ipfix-collector-profile-id}',
            request_body_parameter='i_PFIX_collector_profile',
            path_variables={
                'ipfix_collector_profile_id': 'ipfix-collector-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        operations = {
            'delete': {
                'input_type': delete_input_type,
                'output_type': type.VoidType(),
                'errors': delete_error_dict,
                'input_value_validator_list': delete_input_value_validator_list,
                'output_validator_list': delete_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'get': {
                'input_type': get_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPFIXCollectorProfile'),
                'errors': get_error_dict,
                'input_value_validator_list': get_input_value_validator_list,
                'output_validator_list': get_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'list': {
                'input_type': list_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPFIXCollectorProfileListResult'),
                'errors': list_error_dict,
                'input_value_validator_list': list_input_value_validator_list,
                'output_validator_list': list_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'patch': {
                'input_type': patch_input_type,
                'output_type': type.VoidType(),
                'errors': patch_error_dict,
                'input_value_validator_list': patch_input_value_validator_list,
                'output_validator_list': patch_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'update': {
                'input_type': update_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPFIXCollectorProfile'),
                'errors': update_error_dict,
                'input_value_validator_list': update_input_value_validator_list,
                'output_validator_list': update_output_validator_list,
                'task_type': TaskType.NONE,
            },
        }
        rest_metadata = {
            'delete': delete_rest_metadata,
            'get': get_rest_metadata,
            'list': list_rest_metadata,
            'patch': patch_rest_metadata,
            'update': update_rest_metadata,
        }
        ApiInterfaceStub.__init__(
            self, iface_name='com.vmware.nsx_policy.infra.ipfix_collector_profiles',
            config=config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)

class _IpfixDfwCollectorProfilesStub(ApiInterfaceStub):
    def __init__(self, config):
        # properties for delete operation
        delete_input_type = type.StructType('operation-input', {
            'ipfix_dfw_collector_profile_id': type.StringType(),
        })
        delete_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        delete_input_value_validator_list = [
        ]
        delete_output_validator_list = [
        ]
        delete_rest_metadata = OperationRestMetadata(
            http_method='DELETE',
            url_template='/policy/api/v1/infra/ipfix-dfw-collector-profiles/{ipfix-dfw-collector-profile-id}',
            path_variables={
                'ipfix_dfw_collector_profile_id': 'ipfix-dfw-collector-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for get operation
        get_input_type = type.StructType('operation-input', {
            'ipfix_dfw_collector_profile_id': type.StringType(),
        })
        get_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        get_input_value_validator_list = [
        ]
        get_output_validator_list = [
            HasFieldsOfValidator()
        ]
        get_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/ipfix-dfw-collector-profiles/{ipfix-dfw-collector-profile-id}',
            path_variables={
                'ipfix_dfw_collector_profile_id': 'ipfix-dfw-collector-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for list operation
        list_input_type = type.StructType('operation-input', {
            'cursor': type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.BooleanType()),
            'included_fields': type.OptionalType(type.StringType()),
            'page_size': type.OptionalType(type.IntegerType()),
            'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType()),
        })
        list_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        list_input_value_validator_list = [
        ]
        list_output_validator_list = [
            HasFieldsOfValidator()
        ]
        list_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/ipfix-dfw-collector-profiles',
            path_variables={
            },
            query_parameters={
                'cursor': 'cursor',
                'include_mark_for_delete_objects': 'include_mark_for_delete_objects',
                'included_fields': 'included_fields',
                'page_size': 'page_size',
                'sort_ascending': 'sort_ascending',
                'sort_by': 'sort_by',
            },
            content_type='application/json'
        )

        # properties for patch operation
        patch_input_type = type.StructType('operation-input', {
            'ipfix_dfw_collector_profile_id': type.StringType(),
            'i_PFIXDFW_collector_profile': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPFIXDFWCollectorProfile'),
        })
        patch_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        patch_input_value_validator_list = [
            HasFieldsOfValidator()
        ]
        patch_output_validator_list = [
        ]
        patch_rest_metadata = OperationRestMetadata(
            http_method='PATCH',
            url_template='/policy/api/v1/infra/ipfix-dfw-collector-profiles/{ipfix-dfw-collector-profile-id}',
            request_body_parameter='i_PFIXDFW_collector_profile',
            path_variables={
                'ipfix_dfw_collector_profile_id': 'ipfix-dfw-collector-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for update operation
        update_input_type = type.StructType('operation-input', {
            'ipfix_dfw_collector_profile_id': type.StringType(),
            'i_PFIXDFW_collector_profile': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPFIXDFWCollectorProfile'),
        })
        update_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        update_input_value_validator_list = [
            HasFieldsOfValidator()
        ]
        update_output_validator_list = [
            HasFieldsOfValidator()
        ]
        update_rest_metadata = OperationRestMetadata(
            http_method='PUT',
            url_template='/policy/api/v1/infra/ipfix-dfw-collector-profiles/{ipfix-dfw-collector-profile-id}',
            request_body_parameter='i_PFIXDFW_collector_profile',
            path_variables={
                'ipfix_dfw_collector_profile_id': 'ipfix-dfw-collector-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        operations = {
            'delete': {
                'input_type': delete_input_type,
                'output_type': type.VoidType(),
                'errors': delete_error_dict,
                'input_value_validator_list': delete_input_value_validator_list,
                'output_validator_list': delete_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'get': {
                'input_type': get_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPFIXDFWCollectorProfile'),
                'errors': get_error_dict,
                'input_value_validator_list': get_input_value_validator_list,
                'output_validator_list': get_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'list': {
                'input_type': list_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPFIXDFWCollectorProfileListResult'),
                'errors': list_error_dict,
                'input_value_validator_list': list_input_value_validator_list,
                'output_validator_list': list_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'patch': {
                'input_type': patch_input_type,
                'output_type': type.VoidType(),
                'errors': patch_error_dict,
                'input_value_validator_list': patch_input_value_validator_list,
                'output_validator_list': patch_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'update': {
                'input_type': update_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPFIXDFWCollectorProfile'),
                'errors': update_error_dict,
                'input_value_validator_list': update_input_value_validator_list,
                'output_validator_list': update_output_validator_list,
                'task_type': TaskType.NONE,
            },
        }
        rest_metadata = {
            'delete': delete_rest_metadata,
            'get': get_rest_metadata,
            'list': list_rest_metadata,
            'patch': patch_rest_metadata,
            'update': update_rest_metadata,
        }
        ApiInterfaceStub.__init__(
            self, iface_name='com.vmware.nsx_policy.infra.ipfix_dfw_collector_profiles',
            config=config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)

class _IpfixDfwProfilesStub(ApiInterfaceStub):
    def __init__(self, config):
        # properties for delete operation
        delete_input_type = type.StructType('operation-input', {
            'ipfix_dfw_profile_id': type.StringType(),
        })
        delete_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        delete_input_value_validator_list = [
        ]
        delete_output_validator_list = [
        ]
        delete_rest_metadata = OperationRestMetadata(
            http_method='DELETE',
            url_template='/policy/api/v1/infra/ipfix-dfw-profiles/{ipfix-dfw-profile-id}',
            path_variables={
                'ipfix_dfw_profile_id': 'ipfix-dfw-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for get operation
        get_input_type = type.StructType('operation-input', {
            'ipfix_dfw_profile_id': type.StringType(),
        })
        get_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        get_input_value_validator_list = [
        ]
        get_output_validator_list = [
            HasFieldsOfValidator()
        ]
        get_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/ipfix-dfw-profiles/{ipfix-dfw-profile-id}',
            path_variables={
                'ipfix_dfw_profile_id': 'ipfix-dfw-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for list operation
        list_input_type = type.StructType('operation-input', {
            'cursor': type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.BooleanType()),
            'included_fields': type.OptionalType(type.StringType()),
            'page_size': type.OptionalType(type.IntegerType()),
            'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType()),
        })
        list_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        list_input_value_validator_list = [
        ]
        list_output_validator_list = [
            HasFieldsOfValidator()
        ]
        list_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/ipfix-dfw-profiles',
            path_variables={
            },
            query_parameters={
                'cursor': 'cursor',
                'include_mark_for_delete_objects': 'include_mark_for_delete_objects',
                'included_fields': 'included_fields',
                'page_size': 'page_size',
                'sort_ascending': 'sort_ascending',
                'sort_by': 'sort_by',
            },
            content_type='application/json'
        )

        # properties for patch operation
        patch_input_type = type.StructType('operation-input', {
            'ipfix_dfw_profile_id': type.StringType(),
            'i_PFIXDFW_profile': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPFIXDFWProfile'),
        })
        patch_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        patch_input_value_validator_list = [
            HasFieldsOfValidator()
        ]
        patch_output_validator_list = [
        ]
        patch_rest_metadata = OperationRestMetadata(
            http_method='PATCH',
            url_template='/policy/api/v1/infra/ipfix-dfw-profiles/{ipfix-dfw-profile-id}',
            request_body_parameter='i_PFIXDFW_profile',
            path_variables={
                'ipfix_dfw_profile_id': 'ipfix-dfw-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for update operation
        update_input_type = type.StructType('operation-input', {
            'ipfix_dfw_profile_id': type.StringType(),
            'i_PFIXDFW_profile': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPFIXDFWProfile'),
        })
        update_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        update_input_value_validator_list = [
            HasFieldsOfValidator()
        ]
        update_output_validator_list = [
            HasFieldsOfValidator()
        ]
        update_rest_metadata = OperationRestMetadata(
            http_method='PUT',
            url_template='/policy/api/v1/infra/ipfix-dfw-profiles/{ipfix-dfw-profile-id}',
            request_body_parameter='i_PFIXDFW_profile',
            path_variables={
                'ipfix_dfw_profile_id': 'ipfix-dfw-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        operations = {
            'delete': {
                'input_type': delete_input_type,
                'output_type': type.VoidType(),
                'errors': delete_error_dict,
                'input_value_validator_list': delete_input_value_validator_list,
                'output_validator_list': delete_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'get': {
                'input_type': get_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPFIXDFWProfile'),
                'errors': get_error_dict,
                'input_value_validator_list': get_input_value_validator_list,
                'output_validator_list': get_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'list': {
                'input_type': list_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPFIXDFWProfileListResult'),
                'errors': list_error_dict,
                'input_value_validator_list': list_input_value_validator_list,
                'output_validator_list': list_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'patch': {
                'input_type': patch_input_type,
                'output_type': type.VoidType(),
                'errors': patch_error_dict,
                'input_value_validator_list': patch_input_value_validator_list,
                'output_validator_list': patch_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'update': {
                'input_type': update_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPFIXDFWProfile'),
                'errors': update_error_dict,
                'input_value_validator_list': update_input_value_validator_list,
                'output_validator_list': update_output_validator_list,
                'task_type': TaskType.NONE,
            },
        }
        rest_metadata = {
            'delete': delete_rest_metadata,
            'get': get_rest_metadata,
            'list': list_rest_metadata,
            'patch': patch_rest_metadata,
            'update': update_rest_metadata,
        }
        ApiInterfaceStub.__init__(
            self, iface_name='com.vmware.nsx_policy.infra.ipfix_dfw_profiles',
            config=config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)

class _IpfixL2CollectorProfilesStub(ApiInterfaceStub):
    def __init__(self, config):
        # properties for delete operation
        delete_input_type = type.StructType('operation-input', {
            'ipfix_l2_collector_profile_id': type.StringType(),
        })
        delete_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        delete_input_value_validator_list = [
        ]
        delete_output_validator_list = [
        ]
        delete_rest_metadata = OperationRestMetadata(
            http_method='DELETE',
            url_template='/policy/api/v1/infra/ipfix-l2-collector-profiles/{ipfix-l2-collector-profile-id}',
            path_variables={
                'ipfix_l2_collector_profile_id': 'ipfix-l2-collector-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for get operation
        get_input_type = type.StructType('operation-input', {
            'ipfix_l2_collector_profile_id': type.StringType(),
        })
        get_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        get_input_value_validator_list = [
        ]
        get_output_validator_list = [
            HasFieldsOfValidator()
        ]
        get_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/ipfix-l2-collector-profiles/{ipfix-l2-collector-profile-id}',
            path_variables={
                'ipfix_l2_collector_profile_id': 'ipfix-l2-collector-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for list operation
        list_input_type = type.StructType('operation-input', {
            'cursor': type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.BooleanType()),
            'included_fields': type.OptionalType(type.StringType()),
            'page_size': type.OptionalType(type.IntegerType()),
            'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType()),
        })
        list_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        list_input_value_validator_list = [
        ]
        list_output_validator_list = [
            HasFieldsOfValidator()
        ]
        list_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/ipfix-l2-collector-profiles',
            path_variables={
            },
            query_parameters={
                'cursor': 'cursor',
                'include_mark_for_delete_objects': 'include_mark_for_delete_objects',
                'included_fields': 'included_fields',
                'page_size': 'page_size',
                'sort_ascending': 'sort_ascending',
                'sort_by': 'sort_by',
            },
            content_type='application/json'
        )

        # properties for patch operation
        patch_input_type = type.StructType('operation-input', {
            'ipfix_l2_collector_profile_id': type.StringType(),
            'i_PFIX_l2_collector_profile': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPFIXL2CollectorProfile'),
        })
        patch_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        patch_input_value_validator_list = [
            HasFieldsOfValidator()
        ]
        patch_output_validator_list = [
        ]
        patch_rest_metadata = OperationRestMetadata(
            http_method='PATCH',
            url_template='/policy/api/v1/infra/ipfix-l2-collector-profiles/{ipfix-l2-collector-profile-id}',
            request_body_parameter='i_PFIX_l2_collector_profile',
            path_variables={
                'ipfix_l2_collector_profile_id': 'ipfix-l2-collector-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for update operation
        update_input_type = type.StructType('operation-input', {
            'ipfix_l2_collector_profile_id': type.StringType(),
            'i_PFIX_l2_collector_profile': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPFIXL2CollectorProfile'),
        })
        update_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        update_input_value_validator_list = [
            HasFieldsOfValidator()
        ]
        update_output_validator_list = [
            HasFieldsOfValidator()
        ]
        update_rest_metadata = OperationRestMetadata(
            http_method='PUT',
            url_template='/policy/api/v1/infra/ipfix-l2-collector-profiles/{ipfix-l2-collector-profile-id}',
            request_body_parameter='i_PFIX_l2_collector_profile',
            path_variables={
                'ipfix_l2_collector_profile_id': 'ipfix-l2-collector-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        operations = {
            'delete': {
                'input_type': delete_input_type,
                'output_type': type.VoidType(),
                'errors': delete_error_dict,
                'input_value_validator_list': delete_input_value_validator_list,
                'output_validator_list': delete_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'get': {
                'input_type': get_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPFIXL2CollectorProfile'),
                'errors': get_error_dict,
                'input_value_validator_list': get_input_value_validator_list,
                'output_validator_list': get_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'list': {
                'input_type': list_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPFIXL2CollectorProfileListResult'),
                'errors': list_error_dict,
                'input_value_validator_list': list_input_value_validator_list,
                'output_validator_list': list_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'patch': {
                'input_type': patch_input_type,
                'output_type': type.VoidType(),
                'errors': patch_error_dict,
                'input_value_validator_list': patch_input_value_validator_list,
                'output_validator_list': patch_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'update': {
                'input_type': update_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPFIXL2CollectorProfile'),
                'errors': update_error_dict,
                'input_value_validator_list': update_input_value_validator_list,
                'output_validator_list': update_output_validator_list,
                'task_type': TaskType.NONE,
            },
        }
        rest_metadata = {
            'delete': delete_rest_metadata,
            'get': get_rest_metadata,
            'list': list_rest_metadata,
            'patch': patch_rest_metadata,
            'update': update_rest_metadata,
        }
        ApiInterfaceStub.__init__(
            self, iface_name='com.vmware.nsx_policy.infra.ipfix_l2_collector_profiles',
            config=config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)

class _IpfixL2ProfilesStub(ApiInterfaceStub):
    def __init__(self, config):
        # properties for delete operation
        delete_input_type = type.StructType('operation-input', {
            'ipfix_l2_profile_id': type.StringType(),
        })
        delete_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        delete_input_value_validator_list = [
        ]
        delete_output_validator_list = [
        ]
        delete_rest_metadata = OperationRestMetadata(
            http_method='DELETE',
            url_template='/policy/api/v1/infra/ipfix-l2-profiles/{ipfix-l2-profile-id}',
            path_variables={
                'ipfix_l2_profile_id': 'ipfix-l2-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for get operation
        get_input_type = type.StructType('operation-input', {
            'ipfix_l2_profile_id': type.StringType(),
        })
        get_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        get_input_value_validator_list = [
        ]
        get_output_validator_list = [
            HasFieldsOfValidator()
        ]
        get_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/ipfix-l2-profiles/{ipfix-l2-profile-id}',
            path_variables={
                'ipfix_l2_profile_id': 'ipfix-l2-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for list operation
        list_input_type = type.StructType('operation-input', {
            'cursor': type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.BooleanType()),
            'included_fields': type.OptionalType(type.StringType()),
            'page_size': type.OptionalType(type.IntegerType()),
            'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType()),
        })
        list_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        list_input_value_validator_list = [
        ]
        list_output_validator_list = [
            HasFieldsOfValidator()
        ]
        list_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/ipfix-l2-profiles',
            path_variables={
            },
            query_parameters={
                'cursor': 'cursor',
                'include_mark_for_delete_objects': 'include_mark_for_delete_objects',
                'included_fields': 'included_fields',
                'page_size': 'page_size',
                'sort_ascending': 'sort_ascending',
                'sort_by': 'sort_by',
            },
            content_type='application/json'
        )

        # properties for patch operation
        patch_input_type = type.StructType('operation-input', {
            'ipfix_l2_profile_id': type.StringType(),
            'i_PFIX_l2_profile': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPFIXL2Profile'),
        })
        patch_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        patch_input_value_validator_list = [
            HasFieldsOfValidator()
        ]
        patch_output_validator_list = [
        ]
        patch_rest_metadata = OperationRestMetadata(
            http_method='PATCH',
            url_template='/policy/api/v1/infra/ipfix-l2-profiles/{ipfix-l2-profile-id}',
            request_body_parameter='i_PFIX_l2_profile',
            path_variables={
                'ipfix_l2_profile_id': 'ipfix-l2-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for update operation
        update_input_type = type.StructType('operation-input', {
            'ipfix_l2_profile_id': type.StringType(),
            'i_PFIX_l2_profile': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPFIXL2Profile'),
        })
        update_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        update_input_value_validator_list = [
            HasFieldsOfValidator()
        ]
        update_output_validator_list = [
            HasFieldsOfValidator()
        ]
        update_rest_metadata = OperationRestMetadata(
            http_method='PUT',
            url_template='/policy/api/v1/infra/ipfix-l2-profiles/{ipfix-l2-profile-id}',
            request_body_parameter='i_PFIX_l2_profile',
            path_variables={
                'ipfix_l2_profile_id': 'ipfix-l2-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        operations = {
            'delete': {
                'input_type': delete_input_type,
                'output_type': type.VoidType(),
                'errors': delete_error_dict,
                'input_value_validator_list': delete_input_value_validator_list,
                'output_validator_list': delete_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'get': {
                'input_type': get_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPFIXL2Profile'),
                'errors': get_error_dict,
                'input_value_validator_list': get_input_value_validator_list,
                'output_validator_list': get_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'list': {
                'input_type': list_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPFIXL2ProfileListResult'),
                'errors': list_error_dict,
                'input_value_validator_list': list_input_value_validator_list,
                'output_validator_list': list_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'patch': {
                'input_type': patch_input_type,
                'output_type': type.VoidType(),
                'errors': patch_error_dict,
                'input_value_validator_list': patch_input_value_validator_list,
                'output_validator_list': patch_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'update': {
                'input_type': update_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPFIXL2Profile'),
                'errors': update_error_dict,
                'input_value_validator_list': update_input_value_validator_list,
                'output_validator_list': update_output_validator_list,
                'task_type': TaskType.NONE,
            },
        }
        rest_metadata = {
            'delete': delete_rest_metadata,
            'get': get_rest_metadata,
            'list': list_rest_metadata,
            'patch': patch_rest_metadata,
            'update': update_rest_metadata,
        }
        ApiInterfaceStub.__init__(
            self, iface_name='com.vmware.nsx_policy.infra.ipfix_l2_profiles',
            config=config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)

class _IpsecVpnDpdProfilesStub(ApiInterfaceStub):
    def __init__(self, config):
        # properties for delete operation
        delete_input_type = type.StructType('operation-input', {
            'dpd_profile_id': type.StringType(),
        })
        delete_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        delete_input_value_validator_list = [
        ]
        delete_output_validator_list = [
        ]
        delete_rest_metadata = OperationRestMetadata(
            http_method='DELETE',
            url_template='/policy/api/v1/infra/ipsec-vpn-dpd-profiles/{dpd-profile-id}',
            path_variables={
                'dpd_profile_id': 'dpd-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for get operation
        get_input_type = type.StructType('operation-input', {
            'dpd_profile_id': type.StringType(),
        })
        get_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        get_input_value_validator_list = [
        ]
        get_output_validator_list = [
            HasFieldsOfValidator()
        ]
        get_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/ipsec-vpn-dpd-profiles/{dpd-profile-id}',
            path_variables={
                'dpd_profile_id': 'dpd-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for list operation
        list_input_type = type.StructType('operation-input', {
            'cursor': type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.BooleanType()),
            'included_fields': type.OptionalType(type.StringType()),
            'page_size': type.OptionalType(type.IntegerType()),
            'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType()),
        })
        list_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        list_input_value_validator_list = [
        ]
        list_output_validator_list = [
            HasFieldsOfValidator()
        ]
        list_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/ipsec-vpn-dpd-profiles',
            path_variables={
            },
            query_parameters={
                'cursor': 'cursor',
                'include_mark_for_delete_objects': 'include_mark_for_delete_objects',
                'included_fields': 'included_fields',
                'page_size': 'page_size',
                'sort_ascending': 'sort_ascending',
                'sort_by': 'sort_by',
            },
            content_type='application/json'
        )

        # properties for patch operation
        patch_input_type = type.StructType('operation-input', {
            'dpd_profile_id': type.StringType(),
            'ip_sec_vpn_dpd_profile': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPSecVpnDpdProfile'),
        })
        patch_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        patch_input_value_validator_list = [
            HasFieldsOfValidator()
        ]
        patch_output_validator_list = [
        ]
        patch_rest_metadata = OperationRestMetadata(
            http_method='PATCH',
            url_template='/policy/api/v1/infra/ipsec-vpn-dpd-profiles/{dpd-profile-id}',
            request_body_parameter='ip_sec_vpn_dpd_profile',
            path_variables={
                'dpd_profile_id': 'dpd-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for update operation
        update_input_type = type.StructType('operation-input', {
            'dpd_profile_id': type.StringType(),
            'ip_sec_vpn_dpd_profile': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPSecVpnDpdProfile'),
        })
        update_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        update_input_value_validator_list = [
            HasFieldsOfValidator()
        ]
        update_output_validator_list = [
            HasFieldsOfValidator()
        ]
        update_rest_metadata = OperationRestMetadata(
            http_method='PUT',
            url_template='/policy/api/v1/infra/ipsec-vpn-dpd-profiles/{dpd-profile-id}',
            request_body_parameter='ip_sec_vpn_dpd_profile',
            path_variables={
                'dpd_profile_id': 'dpd-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        operations = {
            'delete': {
                'input_type': delete_input_type,
                'output_type': type.VoidType(),
                'errors': delete_error_dict,
                'input_value_validator_list': delete_input_value_validator_list,
                'output_validator_list': delete_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'get': {
                'input_type': get_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPSecVpnDpdProfile'),
                'errors': get_error_dict,
                'input_value_validator_list': get_input_value_validator_list,
                'output_validator_list': get_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'list': {
                'input_type': list_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPSecVpnDpdProfileListResult'),
                'errors': list_error_dict,
                'input_value_validator_list': list_input_value_validator_list,
                'output_validator_list': list_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'patch': {
                'input_type': patch_input_type,
                'output_type': type.VoidType(),
                'errors': patch_error_dict,
                'input_value_validator_list': patch_input_value_validator_list,
                'output_validator_list': patch_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'update': {
                'input_type': update_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPSecVpnDpdProfile'),
                'errors': update_error_dict,
                'input_value_validator_list': update_input_value_validator_list,
                'output_validator_list': update_output_validator_list,
                'task_type': TaskType.NONE,
            },
        }
        rest_metadata = {
            'delete': delete_rest_metadata,
            'get': get_rest_metadata,
            'list': list_rest_metadata,
            'patch': patch_rest_metadata,
            'update': update_rest_metadata,
        }
        ApiInterfaceStub.__init__(
            self, iface_name='com.vmware.nsx_policy.infra.ipsec_vpn_dpd_profiles',
            config=config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)

class _IpsecVpnIkeProfilesStub(ApiInterfaceStub):
    def __init__(self, config):
        # properties for delete operation
        delete_input_type = type.StructType('operation-input', {
            'ike_profile_id': type.StringType(),
        })
        delete_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        delete_input_value_validator_list = [
        ]
        delete_output_validator_list = [
        ]
        delete_rest_metadata = OperationRestMetadata(
            http_method='DELETE',
            url_template='/policy/api/v1/infra/ipsec-vpn-ike-profiles/{ike-profile-id}',
            path_variables={
                'ike_profile_id': 'ike-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for get operation
        get_input_type = type.StructType('operation-input', {
            'ike_profile_id': type.StringType(),
        })
        get_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        get_input_value_validator_list = [
        ]
        get_output_validator_list = [
            HasFieldsOfValidator()
        ]
        get_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/ipsec-vpn-ike-profiles/{ike-profile-id}',
            path_variables={
                'ike_profile_id': 'ike-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for list operation
        list_input_type = type.StructType('operation-input', {
            'cursor': type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.BooleanType()),
            'included_fields': type.OptionalType(type.StringType()),
            'page_size': type.OptionalType(type.IntegerType()),
            'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType()),
        })
        list_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        list_input_value_validator_list = [
        ]
        list_output_validator_list = [
            HasFieldsOfValidator()
        ]
        list_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/ipsec-vpn-ike-profiles',
            path_variables={
            },
            query_parameters={
                'cursor': 'cursor',
                'include_mark_for_delete_objects': 'include_mark_for_delete_objects',
                'included_fields': 'included_fields',
                'page_size': 'page_size',
                'sort_ascending': 'sort_ascending',
                'sort_by': 'sort_by',
            },
            content_type='application/json'
        )

        # properties for patch operation
        patch_input_type = type.StructType('operation-input', {
            'ike_profile_id': type.StringType(),
            'ip_sec_vpn_ike_profile': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPSecVpnIkeProfile'),
        })
        patch_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        patch_input_value_validator_list = [
            HasFieldsOfValidator()
        ]
        patch_output_validator_list = [
        ]
        patch_rest_metadata = OperationRestMetadata(
            http_method='PATCH',
            url_template='/policy/api/v1/infra/ipsec-vpn-ike-profiles/{ike-profile-id}',
            request_body_parameter='ip_sec_vpn_ike_profile',
            path_variables={
                'ike_profile_id': 'ike-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for update operation
        update_input_type = type.StructType('operation-input', {
            'ike_profile_id': type.StringType(),
            'ip_sec_vpn_ike_profile': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPSecVpnIkeProfile'),
        })
        update_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        update_input_value_validator_list = [
            HasFieldsOfValidator()
        ]
        update_output_validator_list = [
            HasFieldsOfValidator()
        ]
        update_rest_metadata = OperationRestMetadata(
            http_method='PUT',
            url_template='/policy/api/v1/infra/ipsec-vpn-ike-profiles/{ike-profile-id}',
            request_body_parameter='ip_sec_vpn_ike_profile',
            path_variables={
                'ike_profile_id': 'ike-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        operations = {
            'delete': {
                'input_type': delete_input_type,
                'output_type': type.VoidType(),
                'errors': delete_error_dict,
                'input_value_validator_list': delete_input_value_validator_list,
                'output_validator_list': delete_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'get': {
                'input_type': get_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPSecVpnIkeProfile'),
                'errors': get_error_dict,
                'input_value_validator_list': get_input_value_validator_list,
                'output_validator_list': get_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'list': {
                'input_type': list_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPSecVpnIkeProfileListResult'),
                'errors': list_error_dict,
                'input_value_validator_list': list_input_value_validator_list,
                'output_validator_list': list_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'patch': {
                'input_type': patch_input_type,
                'output_type': type.VoidType(),
                'errors': patch_error_dict,
                'input_value_validator_list': patch_input_value_validator_list,
                'output_validator_list': patch_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'update': {
                'input_type': update_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPSecVpnIkeProfile'),
                'errors': update_error_dict,
                'input_value_validator_list': update_input_value_validator_list,
                'output_validator_list': update_output_validator_list,
                'task_type': TaskType.NONE,
            },
        }
        rest_metadata = {
            'delete': delete_rest_metadata,
            'get': get_rest_metadata,
            'list': list_rest_metadata,
            'patch': patch_rest_metadata,
            'update': update_rest_metadata,
        }
        ApiInterfaceStub.__init__(
            self, iface_name='com.vmware.nsx_policy.infra.ipsec_vpn_ike_profiles',
            config=config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)

class _IpsecVpnTunnelProfilesStub(ApiInterfaceStub):
    def __init__(self, config):
        # properties for delete operation
        delete_input_type = type.StructType('operation-input', {
            'tunnel_profile_id': type.StringType(),
        })
        delete_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        delete_input_value_validator_list = [
        ]
        delete_output_validator_list = [
        ]
        delete_rest_metadata = OperationRestMetadata(
            http_method='DELETE',
            url_template='/policy/api/v1/infra/ipsec-vpn-tunnel-profiles/{tunnel-profile-id}',
            path_variables={
                'tunnel_profile_id': 'tunnel-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for get operation
        get_input_type = type.StructType('operation-input', {
            'tunnel_profile_id': type.StringType(),
        })
        get_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        get_input_value_validator_list = [
        ]
        get_output_validator_list = [
            HasFieldsOfValidator()
        ]
        get_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/ipsec-vpn-tunnel-profiles/{tunnel-profile-id}',
            path_variables={
                'tunnel_profile_id': 'tunnel-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for list operation
        list_input_type = type.StructType('operation-input', {
            'cursor': type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.BooleanType()),
            'included_fields': type.OptionalType(type.StringType()),
            'page_size': type.OptionalType(type.IntegerType()),
            'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType()),
        })
        list_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        list_input_value_validator_list = [
        ]
        list_output_validator_list = [
            HasFieldsOfValidator()
        ]
        list_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/ipsec-vpn-tunnel-profiles',
            path_variables={
            },
            query_parameters={
                'cursor': 'cursor',
                'include_mark_for_delete_objects': 'include_mark_for_delete_objects',
                'included_fields': 'included_fields',
                'page_size': 'page_size',
                'sort_ascending': 'sort_ascending',
                'sort_by': 'sort_by',
            },
            content_type='application/json'
        )

        # properties for patch operation
        patch_input_type = type.StructType('operation-input', {
            'tunnel_profile_id': type.StringType(),
            'ip_sec_vpn_tunnel_profile': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPSecVpnTunnelProfile'),
        })
        patch_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        patch_input_value_validator_list = [
            HasFieldsOfValidator()
        ]
        patch_output_validator_list = [
        ]
        patch_rest_metadata = OperationRestMetadata(
            http_method='PATCH',
            url_template='/policy/api/v1/infra/ipsec-vpn-tunnel-profiles/{tunnel-profile-id}',
            request_body_parameter='ip_sec_vpn_tunnel_profile',
            path_variables={
                'tunnel_profile_id': 'tunnel-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for update operation
        update_input_type = type.StructType('operation-input', {
            'tunnel_profile_id': type.StringType(),
            'ip_sec_vpn_tunnel_profile': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPSecVpnTunnelProfile'),
        })
        update_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        update_input_value_validator_list = [
            HasFieldsOfValidator()
        ]
        update_output_validator_list = [
            HasFieldsOfValidator()
        ]
        update_rest_metadata = OperationRestMetadata(
            http_method='PUT',
            url_template='/policy/api/v1/infra/ipsec-vpn-tunnel-profiles/{tunnel-profile-id}',
            request_body_parameter='ip_sec_vpn_tunnel_profile',
            path_variables={
                'tunnel_profile_id': 'tunnel-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        operations = {
            'delete': {
                'input_type': delete_input_type,
                'output_type': type.VoidType(),
                'errors': delete_error_dict,
                'input_value_validator_list': delete_input_value_validator_list,
                'output_validator_list': delete_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'get': {
                'input_type': get_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPSecVpnTunnelProfile'),
                'errors': get_error_dict,
                'input_value_validator_list': get_input_value_validator_list,
                'output_validator_list': get_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'list': {
                'input_type': list_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPSecVpnTunnelProfileListResult'),
                'errors': list_error_dict,
                'input_value_validator_list': list_input_value_validator_list,
                'output_validator_list': list_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'patch': {
                'input_type': patch_input_type,
                'output_type': type.VoidType(),
                'errors': patch_error_dict,
                'input_value_validator_list': patch_input_value_validator_list,
                'output_validator_list': patch_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'update': {
                'input_type': update_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPSecVpnTunnelProfile'),
                'errors': update_error_dict,
                'input_value_validator_list': update_input_value_validator_list,
                'output_validator_list': update_output_validator_list,
                'task_type': TaskType.NONE,
            },
        }
        rest_metadata = {
            'delete': delete_rest_metadata,
            'get': get_rest_metadata,
            'list': list_rest_metadata,
            'patch': patch_rest_metadata,
            'update': update_rest_metadata,
        }
        ApiInterfaceStub.__init__(
            self, iface_name='com.vmware.nsx_policy.infra.ipsec_vpn_tunnel_profiles',
            config=config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)

class _PartnerServicesStub(ApiInterfaceStub):
    def __init__(self, config):
        # properties for get operation
        get_input_type = type.StructType('operation-input', {
            'service_name': type.StringType(),
        })
        get_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        get_input_value_validator_list = [
        ]
        get_output_validator_list = [
        ]
        get_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/partner-services/{service-name}',
            path_variables={
                'service_name': 'service-name',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for list operation
        list_input_type = type.StructType('operation-input', {
            'cursor': type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.BooleanType()),
            'included_fields': type.OptionalType(type.StringType()),
            'page_size': type.OptionalType(type.IntegerType()),
            'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType()),
        })
        list_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        list_input_value_validator_list = [
        ]
        list_output_validator_list = [
        ]
        list_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/partner-services',
            path_variables={
            },
            query_parameters={
                'cursor': 'cursor',
                'include_mark_for_delete_objects': 'include_mark_for_delete_objects',
                'included_fields': 'included_fields',
                'page_size': 'page_size',
                'sort_ascending': 'sort_ascending',
                'sort_by': 'sort_by',
            },
            content_type='application/json'
        )

        operations = {
            'get': {
                'input_type': get_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'ServiceDefinition'),
                'errors': get_error_dict,
                'input_value_validator_list': get_input_value_validator_list,
                'output_validator_list': get_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'list': {
                'input_type': list_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'ServiceInsertionServiceListResult'),
                'errors': list_error_dict,
                'input_value_validator_list': list_input_value_validator_list,
                'output_validator_list': list_output_validator_list,
                'task_type': TaskType.NONE,
            },
        }
        rest_metadata = {
            'get': get_rest_metadata,
            'list': list_rest_metadata,
        }
        ApiInterfaceStub.__init__(
            self, iface_name='com.vmware.nsx_policy.infra.partner_services',
            config=config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)

class _PortMirroringProfilesStub(ApiInterfaceStub):
    def __init__(self, config):
        # properties for delete operation
        delete_input_type = type.StructType('operation-input', {
            'port_mirroring_profile_id': type.StringType(),
        })
        delete_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        delete_input_value_validator_list = [
        ]
        delete_output_validator_list = [
        ]
        delete_rest_metadata = OperationRestMetadata(
            http_method='DELETE',
            url_template='/policy/api/v1/infra/port-mirroring-profiles/{port-mirroring-profile-id}',
            path_variables={
                'port_mirroring_profile_id': 'port-mirroring-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for get operation
        get_input_type = type.StructType('operation-input', {
            'port_mirroring_profile_id': type.StringType(),
        })
        get_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        get_input_value_validator_list = [
        ]
        get_output_validator_list = [
            HasFieldsOfValidator()
        ]
        get_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/port-mirroring-profiles/{port-mirroring-profile-id}',
            path_variables={
                'port_mirroring_profile_id': 'port-mirroring-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for list operation
        list_input_type = type.StructType('operation-input', {
            'cursor': type.OptionalType(type.StringType()),
            'included_fields': type.OptionalType(type.StringType()),
            'page_size': type.OptionalType(type.IntegerType()),
            'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType()),
        })
        list_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        list_input_value_validator_list = [
        ]
        list_output_validator_list = [
            HasFieldsOfValidator()
        ]
        list_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/port-mirroring-profiles',
            path_variables={
            },
            query_parameters={
                'cursor': 'cursor',
                'included_fields': 'included_fields',
                'page_size': 'page_size',
                'sort_ascending': 'sort_ascending',
                'sort_by': 'sort_by',
            },
            content_type='application/json'
        )

        # properties for patch operation
        patch_input_type = type.StructType('operation-input', {
            'port_mirroring_profile_id': type.StringType(),
            'port_mirroring_profile': type.ReferenceType('com.vmware.nsx_policy.model_client', 'PortMirroringProfile'),
        })
        patch_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        patch_input_value_validator_list = [
            HasFieldsOfValidator()
        ]
        patch_output_validator_list = [
        ]
        patch_rest_metadata = OperationRestMetadata(
            http_method='PATCH',
            url_template='/policy/api/v1/infra/port-mirroring-profiles/{port-mirroring-profile-id}',
            request_body_parameter='port_mirroring_profile',
            path_variables={
                'port_mirroring_profile_id': 'port-mirroring-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for update operation
        update_input_type = type.StructType('operation-input', {
            'port_mirroring_profile_id': type.StringType(),
            'port_mirroring_profile': type.ReferenceType('com.vmware.nsx_policy.model_client', 'PortMirroringProfile'),
        })
        update_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        update_input_value_validator_list = [
            HasFieldsOfValidator()
        ]
        update_output_validator_list = [
            HasFieldsOfValidator()
        ]
        update_rest_metadata = OperationRestMetadata(
            http_method='PUT',
            url_template='/policy/api/v1/infra/port-mirroring-profiles/{port-mirroring-profile-id}',
            request_body_parameter='port_mirroring_profile',
            path_variables={
                'port_mirroring_profile_id': 'port-mirroring-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        operations = {
            'delete': {
                'input_type': delete_input_type,
                'output_type': type.VoidType(),
                'errors': delete_error_dict,
                'input_value_validator_list': delete_input_value_validator_list,
                'output_validator_list': delete_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'get': {
                'input_type': get_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'PortMirroringProfile'),
                'errors': get_error_dict,
                'input_value_validator_list': get_input_value_validator_list,
                'output_validator_list': get_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'list': {
                'input_type': list_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'PortMirroringProfileListResult'),
                'errors': list_error_dict,
                'input_value_validator_list': list_input_value_validator_list,
                'output_validator_list': list_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'patch': {
                'input_type': patch_input_type,
                'output_type': type.VoidType(),
                'errors': patch_error_dict,
                'input_value_validator_list': patch_input_value_validator_list,
                'output_validator_list': patch_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'update': {
                'input_type': update_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'PortMirroringProfile'),
                'errors': update_error_dict,
                'input_value_validator_list': update_input_value_validator_list,
                'output_validator_list': update_output_validator_list,
                'task_type': TaskType.NONE,
            },
        }
        rest_metadata = {
            'delete': delete_rest_metadata,
            'get': get_rest_metadata,
            'list': list_rest_metadata,
            'patch': patch_rest_metadata,
            'update': update_rest_metadata,
        }
        ApiInterfaceStub.__init__(
            self, iface_name='com.vmware.nsx_policy.infra.port_mirroring_profiles',
            config=config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)

class _SegmentsStub(ApiInterfaceStub):
    def __init__(self, config):
        # properties for delete operation
        delete_input_type = type.StructType('operation-input', {
            'segment_id': type.StringType(),
        })
        delete_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        delete_input_value_validator_list = [
        ]
        delete_output_validator_list = [
        ]
        delete_rest_metadata = OperationRestMetadata(
            http_method='DELETE',
            url_template='/policy/api/v1/infra/segments/{segment-id}',
            path_variables={
                'segment_id': 'segment-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for delete_0 operation
        delete_0_input_type = type.StructType('operation-input', {
            'segment_id': type.StringType(),
        })
        delete_0_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        delete_0_input_value_validator_list = [
        ]
        delete_0_output_validator_list = [
        ]
        delete_0_rest_metadata = OperationRestMetadata(
            http_method='DELETE',
            url_template='/policy/api/v1/infra/segments/{segment-id}?force=true',
            path_variables={
                'segment_id': 'segment-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for get operation
        get_input_type = type.StructType('operation-input', {
            'segment_id': type.StringType(),
        })
        get_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        get_input_value_validator_list = [
        ]
        get_output_validator_list = [
            HasFieldsOfValidator()
        ]
        get_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/segments/{segment-id}',
            path_variables={
                'segment_id': 'segment-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for list operation
        list_input_type = type.StructType('operation-input', {
            'cursor': type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.BooleanType()),
            'included_fields': type.OptionalType(type.StringType()),
            'page_size': type.OptionalType(type.IntegerType()),
            'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType()),
        })
        list_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        list_input_value_validator_list = [
        ]
        list_output_validator_list = [
            HasFieldsOfValidator()
        ]
        list_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/segments',
            path_variables={
            },
            query_parameters={
                'cursor': 'cursor',
                'include_mark_for_delete_objects': 'include_mark_for_delete_objects',
                'included_fields': 'included_fields',
                'page_size': 'page_size',
                'sort_ascending': 'sort_ascending',
                'sort_by': 'sort_by',
            },
            content_type='application/json'
        )

        # properties for patch operation
        patch_input_type = type.StructType('operation-input', {
            'segment_id': type.StringType(),
            'segment': type.ReferenceType('com.vmware.nsx_policy.model_client', 'Segment'),
        })
        patch_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        patch_input_value_validator_list = [
            HasFieldsOfValidator()
        ]
        patch_output_validator_list = [
        ]
        patch_rest_metadata = OperationRestMetadata(
            http_method='PATCH',
            url_template='/policy/api/v1/infra/segments/{segment-id}',
            request_body_parameter='segment',
            path_variables={
                'segment_id': 'segment-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for update operation
        update_input_type = type.StructType('operation-input', {
            'segment_id': type.StringType(),
            'segment': type.ReferenceType('com.vmware.nsx_policy.model_client', 'Segment'),
        })
        update_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        update_input_value_validator_list = [
            HasFieldsOfValidator()
        ]
        update_output_validator_list = [
            HasFieldsOfValidator()
        ]
        update_rest_metadata = OperationRestMetadata(
            http_method='PUT',
            url_template='/policy/api/v1/infra/segments/{segment-id}',
            request_body_parameter='segment',
            path_variables={
                'segment_id': 'segment-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        operations = {
            'delete': {
                'input_type': delete_input_type,
                'output_type': type.VoidType(),
                'errors': delete_error_dict,
                'input_value_validator_list': delete_input_value_validator_list,
                'output_validator_list': delete_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'delete_0': {
                'input_type': delete_0_input_type,
                'output_type': type.VoidType(),
                'errors': delete_0_error_dict,
                'input_value_validator_list': delete_0_input_value_validator_list,
                'output_validator_list': delete_0_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'get': {
                'input_type': get_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'Segment'),
                'errors': get_error_dict,
                'input_value_validator_list': get_input_value_validator_list,
                'output_validator_list': get_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'list': {
                'input_type': list_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'SegmentListResult'),
                'errors': list_error_dict,
                'input_value_validator_list': list_input_value_validator_list,
                'output_validator_list': list_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'patch': {
                'input_type': patch_input_type,
                'output_type': type.VoidType(),
                'errors': patch_error_dict,
                'input_value_validator_list': patch_input_value_validator_list,
                'output_validator_list': patch_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'update': {
                'input_type': update_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'Segment'),
                'errors': update_error_dict,
                'input_value_validator_list': update_input_value_validator_list,
                'output_validator_list': update_output_validator_list,
                'task_type': TaskType.NONE,
            },
        }
        rest_metadata = {
            'delete': delete_rest_metadata,
            'delete_0': delete_0_rest_metadata,
            'get': get_rest_metadata,
            'list': list_rest_metadata,
            'patch': patch_rest_metadata,
            'update': update_rest_metadata,
        }
        ApiInterfaceStub.__init__(
            self, iface_name='com.vmware.nsx_policy.infra.segments',
            config=config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)

class _ServicesStub(ApiInterfaceStub):
    def __init__(self, config):
        # properties for delete operation
        delete_input_type = type.StructType('operation-input', {
            'service_id': type.StringType(),
        })
        delete_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        delete_input_value_validator_list = [
        ]
        delete_output_validator_list = [
        ]
        delete_rest_metadata = OperationRestMetadata(
            http_method='DELETE',
            url_template='/policy/api/v1/infra/services/{service-id}',
            path_variables={
                'service_id': 'service-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for get operation
        get_input_type = type.StructType('operation-input', {
            'service_id': type.StringType(),
        })
        get_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        get_input_value_validator_list = [
        ]
        get_output_validator_list = [
            HasFieldsOfValidator()
        ]
        get_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/services/{service-id}',
            path_variables={
                'service_id': 'service-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for list operation
        list_input_type = type.StructType('operation-input', {
            'cursor': type.OptionalType(type.StringType()),
            'default_service': type.OptionalType(type.BooleanType()),
            'include_mark_for_delete_objects': type.OptionalType(type.BooleanType()),
            'included_fields': type.OptionalType(type.StringType()),
            'page_size': type.OptionalType(type.IntegerType()),
            'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType()),
        })
        list_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        list_input_value_validator_list = [
        ]
        list_output_validator_list = [
            HasFieldsOfValidator()
        ]
        list_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/services',
            path_variables={
            },
            query_parameters={
                'cursor': 'cursor',
                'default_service': 'default_service',
                'include_mark_for_delete_objects': 'include_mark_for_delete_objects',
                'included_fields': 'included_fields',
                'page_size': 'page_size',
                'sort_ascending': 'sort_ascending',
                'sort_by': 'sort_by',
            },
            content_type='application/json'
        )

        # properties for patch operation
        patch_input_type = type.StructType('operation-input', {
            'service_id': type.StringType(),
            'service': type.ReferenceType('com.vmware.nsx_policy.model_client', 'Service'),
        })
        patch_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        patch_input_value_validator_list = [
            HasFieldsOfValidator()
        ]
        patch_output_validator_list = [
        ]
        patch_rest_metadata = OperationRestMetadata(
            http_method='PATCH',
            url_template='/policy/api/v1/infra/services/{service-id}',
            request_body_parameter='service',
            path_variables={
                'service_id': 'service-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for update operation
        update_input_type = type.StructType('operation-input', {
            'service_id': type.StringType(),
            'service': type.ReferenceType('com.vmware.nsx_policy.model_client', 'Service'),
        })
        update_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        update_input_value_validator_list = [
            HasFieldsOfValidator()
        ]
        update_output_validator_list = [
            HasFieldsOfValidator()
        ]
        update_rest_metadata = OperationRestMetadata(
            http_method='PUT',
            url_template='/policy/api/v1/infra/services/{service-id}',
            request_body_parameter='service',
            path_variables={
                'service_id': 'service-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        operations = {
            'delete': {
                'input_type': delete_input_type,
                'output_type': type.VoidType(),
                'errors': delete_error_dict,
                'input_value_validator_list': delete_input_value_validator_list,
                'output_validator_list': delete_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'get': {
                'input_type': get_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'Service'),
                'errors': get_error_dict,
                'input_value_validator_list': get_input_value_validator_list,
                'output_validator_list': get_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'list': {
                'input_type': list_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'ServiceListResult'),
                'errors': list_error_dict,
                'input_value_validator_list': list_input_value_validator_list,
                'output_validator_list': list_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'patch': {
                'input_type': patch_input_type,
                'output_type': type.VoidType(),
                'errors': patch_error_dict,
                'input_value_validator_list': patch_input_value_validator_list,
                'output_validator_list': patch_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'update': {
                'input_type': update_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'Service'),
                'errors': update_error_dict,
                'input_value_validator_list': update_input_value_validator_list,
                'output_validator_list': update_output_validator_list,
                'task_type': TaskType.NONE,
            },
        }
        rest_metadata = {
            'delete': delete_rest_metadata,
            'get': get_rest_metadata,
            'list': list_rest_metadata,
            'patch': patch_rest_metadata,
            'update': update_rest_metadata,
        }
        ApiInterfaceStub.__init__(
            self, iface_name='com.vmware.nsx_policy.infra.services',
            config=config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)


class StubFactory(StubFactoryBase):
    _attrs = {
        'DhcpRelayConfigs': DhcpRelayConfigs,
        'DhcpServerConfigs': DhcpServerConfigs,
        'DnsForwarderZones': DnsForwarderZones,
        'Domains': Domains,
        'Drafts': Drafts,
        'GroupAssociations': GroupAssociations,
        'IpfixCollectorProfiles': IpfixCollectorProfiles,
        'IpfixDfwCollectorProfiles': IpfixDfwCollectorProfiles,
        'IpfixDfwProfiles': IpfixDfwProfiles,
        'IpfixL2CollectorProfiles': IpfixL2CollectorProfiles,
        'IpfixL2Profiles': IpfixL2Profiles,
        'IpsecVpnDpdProfiles': IpsecVpnDpdProfiles,
        'IpsecVpnIkeProfiles': IpsecVpnIkeProfiles,
        'IpsecVpnTunnelProfiles': IpsecVpnTunnelProfiles,
        'PartnerServices': PartnerServices,
        'PortMirroringProfiles': PortMirroringProfiles,
        'Segments': Segments,
        'Services': Services,
        'domains': 'com.vmware.nsx_policy.infra.domains_client.StubFactory',
        'drafts': 'com.vmware.nsx_policy.infra.drafts_client.StubFactory',
        'realized_state': 'com.vmware.nsx_policy.infra.realized_state_client.StubFactory',
        'segments': 'com.vmware.nsx_policy.infra.segments_client.StubFactory',
        'services': 'com.vmware.nsx_policy.infra.services_client.StubFactory',
        'sites': 'com.vmware.nsx_policy.infra.sites_client.StubFactory',
        'tier_0s': 'com.vmware.nsx_policy.infra.tier_0s_client.StubFactory',
        'tier_1s': 'com.vmware.nsx_policy.infra.tier_1s_client.StubFactory',
    }


7f9193d0534fb3a6119fb779ee06bdf27d91b222
<mask token>


class Drafts(VapiInterface):
    <mask token>
    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.drafts'
    <mask token>

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _DraftsStub)
        self._VAPI_OPERATION_IDS = {}

    def abort(self, draft_id):
        """
        If there is a failure during publish, the admin can choose to abort the
        publishing attempts. This will bring back the system to the current
        configuration, i.e just before the publish was invoked. If draft
        publishing is not in progress or already completed, then this is a
        NO-OP

        :type  draft_id: :class:`str`
        :param draft_id: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('abort', {'draft_id': draft_id})

    def delete(self, draft_id):
        """
        Delete a manual draft.

        :type  draft_id: :class:`str`
        :param draft_id: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete', {'draft_id': draft_id})

    def get(self, draft_id):
        """
        Read a draft for a given draft identifier.

        :type  draft_id: :class:`str`
        :param draft_id: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.PolicyDraft`
        :return: com.vmware.nsx_policy.model.PolicyDraft
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'draft_id': draft_id})

    def list(self, auto_drafts=None, cursor=None,
        include_mark_for_delete_objects=None, included_fields=None,
        page_size=None, sort_ascending=None, sort_by=None):
        """
        List policy drafts.

        :type  auto_drafts: :class:`bool` or ``None``
        :param auto_drafts: Fetch list of draft based on is_auto_draft flag (optional)
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.PolicyDraftListResult`
        :return: com.vmware.nsx_policy.model.PolicyDraftListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'auto_drafts': auto_drafts, 'cursor':
            cursor, 'include_mark_for_delete_objects':
            include_mark_for_delete_objects, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})

    def patch(self, draft_id, policy_draft):
        """
        Create a new manual draft if the specified draft id does not correspond
        to an existing draft. Update the manual draft otherwise. Auto draft can
        not be updated.

        :type  draft_id: :class:`str`
        :param draft_id: (required)
        :type  policy_draft: :class:`com.vmware.nsx_policy.model_client.PolicyDraft`
        :param policy_draft: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch', {'draft_id': draft_id, 'policy_draft':
            policy_draft})

    def publish(self, draft_id, infra):
        """
        Read a draft and publish it by applying changes onto current
        configuration.

        :type  draft_id: :class:`str`
        :param draft_id: (required)
        :type  infra: :class:`com.vmware.nsx_policy.model_client.Infra`
        :param infra: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('publish', {'draft_id': draft_id, 'infra': infra})

    def update(self, draft_id, policy_draft):
        """
        Create a new manual draft if the specified draft id does not correspond
        to an existing draft. Update the manual draft otherwise. Auto draft can
        not be updated.

        :type  draft_id: :class:`str`
        :param draft_id: (required)
        :type  policy_draft: :class:`com.vmware.nsx_policy.model_client.PolicyDraft`
        :param policy_draft: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.PolicyDraft`
        :return: com.vmware.nsx_policy.model.PolicyDraft
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update', {'draft_id': draft_id, 'policy_draft':
            policy_draft})


class GroupAssociations(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.group_associations'
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _GroupAssociationsStub)
        self._VAPI_OPERATION_IDS = {}

    def list(self, intent_path, cursor=None, enforcement_point_path=None,
        include_mark_for_delete_objects=None, included_fields=None,
        page_size=None, sort_ascending=None, sort_by=None):
        """
        Get policy groups for which the given object is a member.

        :type  intent_path: :class:`str`
        :param intent_path: String path of the intent object (required)
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  enforcement_point_path: :class:`str` or ``None``
        :param enforcement_point_path: String Path of the enforcement point (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.PolicyResourceReferenceForEPListResult`
        :return: com.vmware.nsx_policy.model.PolicyResourceReferenceForEPListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'intent_path': intent_path, 'cursor':
            cursor, 'enforcement_point_path': enforcement_point_path,
            'include_mark_for_delete_objects':
            include_mark_for_delete_objects, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})


class IpfixCollectorProfiles(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.ipfix_collector_profiles'
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _IpfixCollectorProfilesStub)
        self._VAPI_OPERATION_IDS = {}

    def delete(self, ipfix_collector_profile_id):
        """
        API deletes IPFIX collector profile. Flow forwarding to collector will
        be stopped. This API is deprecated. Please use the following API:
        https://<policy-mgr>/policy/api/v1/infra/ipfix-l2-collector-profiles

        :type  ipfix_collector_profile_id: :class:`str`
        :param ipfix_collector_profile_id: IPFIX collector Profile id (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete', {'ipfix_collector_profile_id':
            ipfix_collector_profile_id})

    def get(self, ipfix_collector_profile_id):
        """
        API will return details of IPFIX collector profile. If profile does not
        exist, it will return 404. This API is deprecated. Please use the
        following API:
        https://<policy-mgr>/policy/api/v1/infra/ipfix-l2-collector-profiles

        :type  ipfix_collector_profile_id: :class:`str`
        :param ipfix_collector_profile_id: IPFIX collector profile id (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXCollectorProfile`
        :return: com.vmware.nsx_policy.model.IPFIXCollectorProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'ipfix_collector_profile_id':
            ipfix_collector_profile_id})

    def list(self, cursor=None, include_mark_for_delete_objects=None,
        included_fields=None, page_size=None, sort_ascending=None, sort_by=None
        ):
        """
        API will provide list of all IPFIX collector profiles and their
        details. This API is deprecated. Please use the following API:
        https://<policy-mgr>/policy/api/v1/infra/ipfix-l2-collector-profiles

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXCollectorProfileListResult`
        :return: com.vmware.nsx_policy.model.IPFIXCollectorProfileListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'cursor': cursor,
            'include_mark_for_delete_objects':
            include_mark_for_delete_objects, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})

    def patch(self, ipfix_collector_profile_id, i_pfix_collector_profile):
        """
        Create a new IPFIX collector profile if the IPFIX collector profile
        with given id does not already exist. If the IPFIX collector profile
        with the given id already exists, patch with the existing IPFIX
        collector profile. This API is deprecated. Please use the following
        API:
        https://<policy-mgr>/policy/api/v1/infra/ipfix-l2-collector-profiles

        :type  ipfix_collector_profile_id: :class:`str`
        :param ipfix_collector_profile_id: IPFIX collector profile id (required)
        :type  i_pfix_collector_profile: :class:`com.vmware.nsx_policy.model_client.IPFIXCollectorProfile`
        :param i_pfix_collector_profile: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch', {'ipfix_collector_profile_id':
            ipfix_collector_profile_id, 'i_pfix_collector_profile':
            i_pfix_collector_profile})

    def update(self, ipfix_collector_profile_id, i_pfix_collector_profile):
        """
        Create or Replace IPFIX collector profile. IPFIX data will be sent to
        IPFIX collector port. This API is deprecated. Please use the following
        API:
        https://<policy-mgr>/policy/api/v1/infra/ipfix-l2-collector-profiles

        :type  ipfix_collector_profile_id: :class:`str`
        :param ipfix_collector_profile_id: IPFIX collector profile id (required)
        :type  i_pfix_collector_profile: :class:`com.vmware.nsx_policy.model_client.IPFIXCollectorProfile`
        :param i_pfix_collector_profile: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXCollectorProfile`
        :return: com.vmware.nsx_policy.model.IPFIXCollectorProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update', {'ipfix_collector_profile_id':
            ipfix_collector_profile_id, 'i_pfix_collector_profile':
            i_pfix_collector_profile})


class IpfixDfwCollectorProfiles(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = (
        'com.vmware.nsx_policy.infra.ipfix_dfw_collector_profiles')
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _IpfixDfwCollectorProfilesStub)
        self._VAPI_OPERATION_IDS = {}

    def delete(self, ipfix_dfw_collector_profile_id):
        """
        API deletes IPFIX dfw collector profile. Flow forwarding to collector
        will be stopped.

        :type  ipfix_dfw_collector_profile_id: :class:`str`
        :param ipfix_dfw_collector_profile_id: IPFIX dfw collector Profile id (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete', {'ipfix_dfw_collector_profile_id':
            ipfix_dfw_collector_profile_id})

    def get(self, ipfix_dfw_collector_profile_id):
        """
        API will return details of IPFIX dfw collector profile. If profile does
        not exist, it will return 404.

        :type  ipfix_dfw_collector_profile_id: :class:`str`
        :param ipfix_dfw_collector_profile_id: IPFIX dfw collector profile id (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXDFWCollectorProfile`
        :return: com.vmware.nsx_policy.model.IPFIXDFWCollectorProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'ipfix_dfw_collector_profile_id':
            ipfix_dfw_collector_profile_id})

    def list(self, cursor=None, include_mark_for_delete_objects=None,
        included_fields=None, page_size=None, sort_ascending=None, sort_by=None
        ):
        """
        API will provide list of all IPFIX dfw collector profiles and their
        details.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXDFWCollectorProfileListResult`
        :return: com.vmware.nsx_policy.model.IPFIXDFWCollectorProfileListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'cursor': cursor,
            'include_mark_for_delete_objects':
            include_mark_for_delete_objects, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})

    def patch(self, ipfix_dfw_collector_profile_id, i_pfixdfw_collector_profile
        ):
        """
        Create a new IPFIX dfw collector profile if the IPFIX dfw collector
        profile with given id does not already exist. If the IPFIX dfw
        collector profile with the given id already exists, patch with the
        existing IPFIX dfw collector profile.

        :type  ipfix_dfw_collector_profile_id: :class:`str`
        :param ipfix_dfw_collector_profile_id: (required)
        :type  i_pfixdfw_collector_profile: :class:`com.vmware.nsx_policy.model_client.IPFIXDFWCollectorProfile`
        :param i_pfixdfw_collector_profile: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch', {'ipfix_dfw_collector_profile_id':
            ipfix_dfw_collector_profile_id, 'i_pfixdfw_collector_profile':
            i_pfixdfw_collector_profile})

    def update(self, ipfix_dfw_collector_profile_id,
        i_pfixdfw_collector_profile):
        """
        Create or Replace IPFIX dfw collector profile. IPFIX data will be sent
        to IPFIX collector port.

        :type  ipfix_dfw_collector_profile_id: :class:`str`
        :param ipfix_dfw_collector_profile_id: IPFIX dfw collector profile id (required)
        :type  i_pfixdfw_collector_profile: :class:`com.vmware.nsx_policy.model_client.IPFIXDFWCollectorProfile`
        :param i_pfixdfw_collector_profile: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXDFWCollectorProfile`
        :return: com.vmware.nsx_policy.model.IPFIXDFWCollectorProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update', {'ipfix_dfw_collector_profile_id':
            ipfix_dfw_collector_profile_id, 'i_pfixdfw_collector_profile':
            i_pfixdfw_collector_profile})


class IpfixDfwProfiles(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.ipfix_dfw_profiles'
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _IpfixDfwProfilesStub)
        self._VAPI_OPERATION_IDS = {}

    def delete(self, ipfix_dfw_profile_id):
        """
        API deletes IPFIX DFW Profile. Selected IPFIX Collectors will stop
        receiving flows.

        :type  ipfix_dfw_profile_id: :class:`str`
        :param ipfix_dfw_profile_id: IPFIX DFW Profile ID (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete', {'ipfix_dfw_profile_id':
            ipfix_dfw_profile_id})

    def get(self, ipfix_dfw_profile_id):
        """
        API will return details of IPFIX DFW profile.

        :type  ipfix_dfw_profile_id: :class:`str`
        :param ipfix_dfw_profile_id: IPFIX DFW collection id (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXDFWProfile`
        :return: com.vmware.nsx_policy.model.IPFIXDFWProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'ipfix_dfw_profile_id':
            ipfix_dfw_profile_id})

    def list(self, cursor=None, include_mark_for_delete_objects=None,
        included_fields=None, page_size=None, sort_ascending=None, sort_by=None
        ):
        """
        API provides list IPFIX DFW profiles available on selected logical DFW.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXDFWProfileListResult`
        :return: com.vmware.nsx_policy.model.IPFIXDFWProfileListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'cursor': cursor,
            'include_mark_for_delete_objects':
            include_mark_for_delete_objects, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})

    def patch(self, ipfix_dfw_profile_id, i_pfixdfw_profile):
        """
        Create a new IPFIX DFW profile if the IPFIX DFW profile with given id
        does not already exist. If the IPFIX DFW profile with the given id
        already exists, patch with the existing IPFIX DFW profile.

        :type  ipfix_dfw_profile_id: :class:`str`
        :param ipfix_dfw_profile_id: IPFIX DFW Profile ID (required)
        :type  i_pfixdfw_profile: :class:`com.vmware.nsx_policy.model_client.IPFIXDFWProfile`
        :param i_pfixdfw_profile: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch', {'ipfix_dfw_profile_id':
            ipfix_dfw_profile_id, 'i_pfixdfw_profile': i_pfixdfw_profile})

    def update(self, ipfix_dfw_profile_id, i_pfixdfw_profile):
        """
        Create or replace IPFIX DFW profile. Config will start forwarding data
        to provided IPFIX DFW collector.

        :type  ipfix_dfw_profile_id: :class:`str`
        :param ipfix_dfw_profile_id: IPFIX DFW Profile ID (required)
        :type  i_pfixdfw_profile: :class:`com.vmware.nsx_policy.model_client.IPFIXDFWProfile`
        :param i_pfixdfw_profile: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXDFWProfile`
        :return: com.vmware.nsx_policy.model.IPFIXDFWProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update', {'ipfix_dfw_profile_id':
            ipfix_dfw_profile_id, 'i_pfixdfw_profile': i_pfixdfw_profile})


class IpfixL2CollectorProfiles(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = (
        'com.vmware.nsx_policy.infra.ipfix_l2_collector_profiles')
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _IpfixL2CollectorProfilesStub)
        self._VAPI_OPERATION_IDS = {}

    def delete(self, ipfix_l2_collector_profile_id):
        """
        API deletes IPFIX collector profile. Flow forwarding to collector will
        be stopped.

        :type  ipfix_l2_collector_profile_id: :class:`str`
        :param ipfix_l2_collector_profile_id: IPFIX collector Profile id (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete', {'ipfix_l2_collector_profile_id':
            ipfix_l2_collector_profile_id})

    def get(self, ipfix_l2_collector_profile_id):
        """
        API will return details of IPFIX collector profile.

        :type  ipfix_l2_collector_profile_id: :class:`str`
        :param ipfix_l2_collector_profile_id: IPFIX collector profile id (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXL2CollectorProfile`
        :return: com.vmware.nsx_policy.model.IPFIXL2CollectorProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'ipfix_l2_collector_profile_id':
            ipfix_l2_collector_profile_id})

    def list(self, cursor=None, include_mark_for_delete_objects=None,
        included_fields=None, page_size=None, sort_ascending=None, sort_by=None
        ):
        """
        API will provide list of all IPFIX collector profiles and their
        details.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXL2CollectorProfileListResult`
        :return: com.vmware.nsx_policy.model.IPFIXL2CollectorProfileListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'cursor': cursor,
            'include_mark_for_delete_objects':
            include_mark_for_delete_objects, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})

    def patch(self, ipfix_l2_collector_profile_id, i_pfix_l2_collector_profile
        ):
        """
        Create a new IPFIX collector profile if the IPFIX collector profile
        with given id does not already exist. If the IPFIX collector profile
        with the given id already exists, patch with the existing IPFIX
        collector profile.

        :type  ipfix_l2_collector_profile_id: :class:`str`
        :param ipfix_l2_collector_profile_id: IPFIX collector profile id (required)
        :type  i_pfix_l2_collector_profile: :class:`com.vmware.nsx_policy.model_client.IPFIXL2CollectorProfile`
        :param i_pfix_l2_collector_profile: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch', {'ipfix_l2_collector_profile_id':
            ipfix_l2_collector_profile_id, 'i_pfix_l2_collector_profile':
            i_pfix_l2_collector_profile})

    def update(self, ipfix_l2_collector_profile_id, i_pfix_l2_collector_profile
        ):
        """
        Create or Replace IPFIX collector profile. IPFIX data will be sent to
        IPFIX collector.

        :type  ipfix_l2_collector_profile_id: :class:`str`
        :param ipfix_l2_collector_profile_id: IPFIX collector profile id (required)
        :type  i_pfix_l2_collector_profile: :class:`com.vmware.nsx_policy.model_client.IPFIXL2CollectorProfile`
        :param i_pfix_l2_collector_profile: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXL2CollectorProfile`
        :return: com.vmware.nsx_policy.model.IPFIXL2CollectorProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update', {'ipfix_l2_collector_profile_id':
            ipfix_l2_collector_profile_id, 'i_pfix_l2_collector_profile':
            i_pfix_l2_collector_profile})


class IpfixL2Profiles(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.ipfix_l2_profiles'
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _IpfixL2ProfilesStub)
        self._VAPI_OPERATION_IDS = {}

    def delete(self, ipfix_l2_profile_id):
        """
        API deletes IPFIX L2 Profile. Flow forwarding to selected collector
        will be stopped.

        :type  ipfix_l2_profile_id: :class:`str`
        :param ipfix_l2_profile_id: IPFIX L2 Profile ID (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete', {'ipfix_l2_profile_id':
            ipfix_l2_profile_id})

    def get(self, ipfix_l2_profile_id):
        """
        API will return details of IPFIX L2 profile.

        :type  ipfix_l2_profile_id: :class:`str`
        :param ipfix_l2_profile_id: IPFIX L2 profile id (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXL2Profile`
        :return: com.vmware.nsx_policy.model.IPFIXL2Profile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'ipfix_l2_profile_id': ipfix_l2_profile_id}
            )

    def list(self, cursor=None, include_mark_for_delete_objects=None,
        included_fields=None, page_size=None, sort_ascending=None, sort_by=None
        ):
        """
        API provides list IPFIX L2 Profiles available on selected logical l2.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXL2ProfileListResult`
        :return: com.vmware.nsx_policy.model.IPFIXL2ProfileListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'cursor': cursor,
            'include_mark_for_delete_objects':
            include_mark_for_delete_objects, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})

    def patch(self, ipfix_l2_profile_id, i_pfix_l2_profile):
        """
        Create a new IPFIX L2 profile if the IPFIX L2 profile with given id
        does not already exist. If the IPFIX L2 profile with the given id
        already exists, patch with the existing IPFIX L2 profile.

        :type  ipfix_l2_profile_id: :class:`str`
        :param ipfix_l2_profile_id: IPFIX L2 Profile ID (required)
        :type  i_pfix_l2_profile: :class:`com.vmware.nsx_policy.model_client.IPFIXL2Profile`
        :param i_pfix_l2_profile: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch', {'ipfix_l2_profile_id':
            ipfix_l2_profile_id, 'i_pfix_l2_profile': i_pfix_l2_profile})

    def update(self, ipfix_l2_profile_id, i_pfix_l2_profile):
        """
        Create or replace IPFIX L2 Profile. Profile is reusable entity. Single
        profile can attached multiple bindings e.g group, segment and port.

        :type  ipfix_l2_profile_id: :class:`str`
        :param ipfix_l2_profile_id: IPFIX L2 Profile ID (required)
        :type  i_pfix_l2_profile: :class:`com.vmware.nsx_policy.model_client.IPFIXL2Profile`
        :param i_pfix_l2_profile: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXL2Profile`
        :return: com.vmware.nsx_policy.model.IPFIXL2Profile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update', {'ipfix_l2_profile_id':
            ipfix_l2_profile_id, 'i_pfix_l2_profile': i_pfix_l2_profile})


class IpsecVpnDpdProfiles(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.ipsec_vpn_dpd_profiles'
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _IpsecVpnDpdProfilesStub)
        self._VAPI_OPERATION_IDS = {}

    def delete(self, dpd_profile_id):
        """
        Delete custom dead peer detection (DPD) profile. Profile can not be
        deleted if profile has references to it.

        :type  dpd_profile_id: :class:`str`
        :param dpd_profile_id: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete', {'dpd_profile_id': dpd_profile_id})

    def get(self, dpd_profile_id):
        """
        Get custom dead peer detection (DPD) profile, given the particular id.

        :type  dpd_profile_id: :class:`str`
        :param dpd_profile_id: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPSecVpnDpdProfile`
        :return: com.vmware.nsx_policy.model.IPSecVpnDpdProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'dpd_profile_id': dpd_profile_id})

    def list(self, cursor=None, include_mark_for_delete_objects=None,
        included_fields=None, page_size=None, sort_ascending=None, sort_by=None
        ):
        """
        Get paginated list of all DPD Profiles.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPSecVpnDpdProfileListResult`
        :return: com.vmware.nsx_policy.model.IPSecVpnDpdProfileListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'cursor': cursor,
            'include_mark_for_delete_objects':
            include_mark_for_delete_objects, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})

    def patch(self, dpd_profile_id, ip_sec_vpn_dpd_profile):
        """
        Create or patch dead peer detection (DPD) profile. Any change in
        profile affects all sessions consuming this profile. System will be
        provisioned with system owned editable default DPD profile. Any change
        in profile affects all sessions consuming this profile.

        :type  dpd_profile_id: :class:`str`
        :param dpd_profile_id: (required)
        :type  ip_sec_vpn_dpd_profile: :class:`com.vmware.nsx_policy.model_client.IPSecVpnDpdProfile`
        :param ip_sec_vpn_dpd_profile: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch', {'dpd_profile_id': dpd_profile_id,
            'ip_sec_vpn_dpd_profile': ip_sec_vpn_dpd_profile})

    def update(self, dpd_profile_id, ip_sec_vpn_dpd_profile):
        """
        Create or patch dead peer detection (DPD) profile. Any change in
        profile affects all sessions consuming this profile. System will be
        provisioned with system owned editable default DPD profile. Any change
        in profile affects all sessions consuming this profile. Revision is
        optional for creation and required for update.

        :type  dpd_profile_id: :class:`str`
        :param dpd_profile_id: (required)
        :type  ip_sec_vpn_dpd_profile: :class:`com.vmware.nsx_policy.model_client.IPSecVpnDpdProfile`
        :param ip_sec_vpn_dpd_profile: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPSecVpnDpdProfile`
        :return: com.vmware.nsx_policy.model.IPSecVpnDpdProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update', {'dpd_profile_id': dpd_profile_id,
            'ip_sec_vpn_dpd_profile': ip_sec_vpn_dpd_profile})


class IpsecVpnIkeProfiles(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.ipsec_vpn_ike_profiles'
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _IpsecVpnIkeProfilesStub)
        self._VAPI_OPERATION_IDS = {}

    def delete(self, ike_profile_id):
        """
        Delete custom IKE Profile. Profile can not be deleted if profile has
        references to it.

        :type  ike_profile_id: :class:`str`
        :param ike_profile_id: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete', {'ike_profile_id': ike_profile_id})

    def get(self, ike_profile_id):
        """
        Get custom IKE Profile, given the particular id.

        :type  ike_profile_id: :class:`str`
        :param ike_profile_id: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPSecVpnIkeProfile`
        :return: com.vmware.nsx_policy.model.IPSecVpnIkeProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'ike_profile_id': ike_profile_id})

    def list(self, cursor=None, include_mark_for_delete_objects=None,
        included_fields=None, page_size=None, sort_ascending=None, sort_by=None
        ):
        """
        Get paginated list of all IKE Profiles.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPSecVpnIkeProfileListResult`
        :return: com.vmware.nsx_policy.model.IPSecVpnIkeProfileListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'cursor': cursor,
            'include_mark_for_delete_objects':
            include_mark_for_delete_objects, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})

    def patch(self, ike_profile_id, ip_sec_vpn_ike_profile):
        """
        Create or patch custom internet key exchange (IKE) Profile. IKE Profile
        is a reusable profile that captures IKE and phase one negotiation
        parameters. System will be pre provisioned with system owned editable
        default IKE profile and suggested set of profiles that can be used for
        peering with popular remote peers like AWS VPN. User can create custom
        profiles as needed. Any change in profile affects all sessions
        consuming this profile.

        :type  ike_profile_id: :class:`str`
        :param ike_profile_id: (required)
        :type  ip_sec_vpn_ike_profile: :class:`com.vmware.nsx_policy.model_client.IPSecVpnIkeProfile`
        :param ip_sec_vpn_ike_profile: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch', {'ike_profile_id': ike_profile_id,
            'ip_sec_vpn_ike_profile': ip_sec_vpn_ike_profile})

    def update(self, ike_profile_id, ip_sec_vpn_ike_profile):
        """
        Create or fully replace custom internet key exchange (IKE) Profile. IKE
        Profile is a reusable profile that captures IKE and phase one
        negotiation parameters. System will be pre provisioned with system
        owned editable default IKE profile and suggested set of profiles that
        can be used for peering with popular remote peers like AWS VPN. User
        can create custom profiles as needed. Any change in profile affects all
        sessions consuming this profile. Revision is optional for creation and
        required for update.

        :type  ike_profile_id: :class:`str`
        :param ike_profile_id: (required)
        :type  ip_sec_vpn_ike_profile: :class:`com.vmware.nsx_policy.model_client.IPSecVpnIkeProfile`
        :param ip_sec_vpn_ike_profile: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPSecVpnIkeProfile`
        :return: com.vmware.nsx_policy.model.IPSecVpnIkeProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update', {'ike_profile_id': ike_profile_id,
            'ip_sec_vpn_ike_profile': ip_sec_vpn_ike_profile})


class IpsecVpnTunnelProfiles(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.ipsec_vpn_tunnel_profiles'
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _IpsecVpnTunnelProfilesStub)
        self._VAPI_OPERATION_IDS = {}

    def delete(self, tunnel_profile_id):
        """
        Delete custom IPSec tunnel Profile. Profile can not be deleted if
        profile has references to it.

        :type  tunnel_profile_id: :class:`str`
        :param tunnel_profile_id: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete', {'tunnel_profile_id': tunnel_profile_id})

    def get(self, tunnel_profile_id):
        """
        Get custom IPSec tunnel Profile, given the particular id.

        :type  tunnel_profile_id: :class:`str`
        :param tunnel_profile_id: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPSecVpnTunnelProfile`
        :return: com.vmware.nsx_policy.model.IPSecVpnTunnelProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'tunnel_profile_id': tunnel_profile_id})

    def list(self, cursor=None, include_mark_for_delete_objects=None,
        included_fields=None, page_size=None, sort_ascending=None, sort_by=None
        ):
        """
        Get paginated list of all IPSec tunnel Profiles.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPSecVpnTunnelProfileListResult`
        :return: com.vmware.nsx_policy.model.IPSecVpnTunnelProfileListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'cursor': cursor,
            'include_mark_for_delete_objects':
            include_mark_for_delete_objects, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})

    def patch(self, tunnel_profile_id, ip_sec_vpn_tunnel_profile):
        """
        Create or patch custom IPSec tunnel profile. IPSec tunnel profile is a
        reusable profile that captures phase two negotiation parameters and
        tunnel properties. System will be provisioned with system owned
        editable default IPSec tunnel profile. Any change in profile affects
        all sessions consuming this profile.

        :type  tunnel_profile_id: :class:`str`
        :param tunnel_profile_id: (required)
        :type  ip_sec_vpn_tunnel_profile: :class:`com.vmware.nsx_policy.model_client.IPSecVpnTunnelProfile`
        :param ip_sec_vpn_tunnel_profile: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch', {'tunnel_profile_id':
            tunnel_profile_id, 'ip_sec_vpn_tunnel_profile':
            ip_sec_vpn_tunnel_profile})

    def update(self, tunnel_profile_id, ip_sec_vpn_tunnel_profile):
        """
        Create or fully replace custom IPSec tunnel profile. IPSec tunnel
        profile is a reusable profile that captures phase two negotiation
        parameters and tunnel properties. System will be provisioned with
        system owned editable default IPSec tunnel profile. Any change in
        profile affects all sessions consuming this profile. Revision is
        optional for creation and required for update.

        :type  tunnel_profile_id: :class:`str`
        :param tunnel_profile_id: (required)
        :type  ip_sec_vpn_tunnel_profile: :class:`com.vmware.nsx_policy.model_client.IPSecVpnTunnelProfile`
        :param ip_sec_vpn_tunnel_profile: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPSecVpnTunnelProfile`
        :return: com.vmware.nsx_policy.model.IPSecVpnTunnelProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update', {'tunnel_profile_id':
            tunnel_profile_id, 'ip_sec_vpn_tunnel_profile':
            ip_sec_vpn_tunnel_profile})


class PartnerServices(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.partner_services'
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _PartnerServicesStub)
        self._VAPI_OPERATION_IDS = {}

    def get(self, service_name):
        """
        Read the specific partner service identified by provided name.

        :type  service_name: :class:`str`
        :param service_name: Name of the service (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.ServiceDefinition`
        :return: com.vmware.nsx_policy.model.ServiceDefinition
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'service_name': service_name})

    def list(self, cursor=None, include_mark_for_delete_objects=None,
        included_fields=None, page_size=None, sort_ascending=None, sort_by=None
        ):
        """
        Read all the partner services available for service insertion

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.ServiceInsertionServiceListResult`
        :return: com.vmware.nsx_policy.model.ServiceInsertionServiceListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'cursor': cursor,
            'include_mark_for_delete_objects':
            include_mark_for_delete_objects, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})


class PortMirroringProfiles(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.port_mirroring_profiles'
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _PortMirroringProfilesStub)
        self._VAPI_OPERATION_IDS = {}

    def delete(self, port_mirroring_profile_id):
        """
        API will delete port mirroring profile. Mirroring from source to
        destination ports will be stopped.

        :type  port_mirroring_profile_id: :class:`str`
        :param port_mirroring_profile_id: Port Mirroring Profile Id (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete', {'port_mirroring_profile_id':
            port_mirroring_profile_id})

    def get(self, port_mirroring_profile_id):
        """
        API will return details of port mirroring profile.

        :type  port_mirroring_profile_id: :class:`str`
        :param port_mirroring_profile_id: Port Mirroring Profile Id (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.PortMirroringProfile`
        :return: com.vmware.nsx_policy.model.PortMirroringProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'port_mirroring_profile_id':
            port_mirroring_profile_id})

    def list(self, cursor=None, included_fields=None, page_size=None,
        sort_ascending=None, sort_by=None):
        """
        API will list all port mirroring profiles group.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.PortMirroringProfileListResult`
        :return: com.vmware.nsx_policy.model.PortMirroringProfileListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'cursor': cursor, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})

    def patch(self, port_mirroring_profile_id, port_mirroring_profile):
        """
        Create a new Port Mirroring Profile if the Port Mirroring Profile with
        given id does not already exist. If the Port Mirroring Profile with the
        given id already exists, patch with the existing Port Mirroring
        Profile. Realized entities of this API can be found using the path of
        monitoring profile binding map that is used to apply this profile.

        :type  port_mirroring_profile_id: :class:`str`
        :param port_mirroring_profile_id: Port Mirroring Profile Id (required)
        :type  port_mirroring_profile: :class:`com.vmware.nsx_policy.model_client.PortMirroringProfile`
        :param port_mirroring_profile: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch', {'port_mirroring_profile_id':
            port_mirroring_profile_id, 'port_mirroring_profile':
            port_mirroring_profile})

    def update(self, port_mirroring_profile_id, port_mirroring_profile):
        """
        Create or Replace port mirroring profile. Packets will be mirrored from
        source group, segment, port to destination group. Realized entities of
        this API can be found using the path of monitoring profile binding map
        that is used to apply this profile.

        :type  port_mirroring_profile_id: :class:`str`
        :param port_mirroring_profile_id: Port Mirroring Profiles Id (required)
        :type  port_mirroring_profile: :class:`com.vmware.nsx_policy.model_client.PortMirroringProfile`
        :param port_mirroring_profile: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.PortMirroringProfile`
        :return: com.vmware.nsx_policy.model.PortMirroringProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update', {'port_mirroring_profile_id':
            port_mirroring_profile_id, 'port_mirroring_profile':
            port_mirroring_profile})


class Segments(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.segments'
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _SegmentsStub)
        self._VAPI_OPERATION_IDS = {}

    def delete(self, segment_id):
        """
        Delete infra segment

        :type  segment_id: :class:`str`
        :param segment_id: Segment ID (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete', {'segment_id': segment_id})

    def delete_0(self, segment_id):
        """
        Force delete bypasses validations during segment deletion. This may
        result in an inconsistent connectivity.

        :type  segment_id: :class:`str`
        :param segment_id: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete_0', {'segment_id': segment_id})

    def get(self, segment_id):
        """
        Read infra segment

        :type  segment_id: :class:`str`
        :param segment_id: Segment ID (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.Segment`
        :return: com.vmware.nsx_policy.model.Segment
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'segment_id': segment_id})

    def list(self, cursor=None, include_mark_for_delete_objects=None,
        included_fields=None, page_size=None, sort_ascending=None, sort_by=None
        ):
        """
        Paginated list of all segments under infra.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.SegmentListResult`
        :return: com.vmware.nsx_policy.model.SegmentListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'cursor': cursor,
            'include_mark_for_delete_objects':
            include_mark_for_delete_objects, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})

    def patch(self, segment_id, segment):
        """
        If segment with the segment-id is not already present, create a new
        segment. If it already exists, update the segment with specified
        attributes.

        :type  segment_id: :class:`str`
        :param segment_id: Segment ID (required)
        :type  segment: :class:`com.vmware.nsx_policy.model_client.Segment`
        :param segment: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch', {'segment_id': segment_id, 'segment':
            segment})

    def update(self, segment_id, segment):
        """
        If segment with the segment-id is not already present, create a new
        segment. If it already exists, replace the segment with this object.

        :type  segment_id: :class:`str`
        :param segment_id: Segment ID (required)
        :type  segment: :class:`com.vmware.nsx_policy.model_client.Segment`
        :param segment: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.Segment`
        :return: com.vmware.nsx_policy.model.Segment
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update', {'segment_id': segment_id, 'segment':
            segment})


class Services(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.services'
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _ServicesStub)
        self._VAPI_OPERATION_IDS = {}

    def delete(self, service_id):
        """
        Delete Service

        :type  service_id: :class:`str`
        :param service_id: Service ID (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete', {'service_id': service_id})

    def get(self, service_id):
        """
        Read a service

        :type  service_id: :class:`str`
        :param service_id: Service ID (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.Service`
        :return: com.vmware.nsx_policy.model.Service
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'service_id': service_id})

    def list(self, cursor=None, default_service=None,
        include_mark_for_delete_objects=None, included_fields=None,
        page_size=None, sort_ascending=None, sort_by=None):
        """
        Paginated list of Services for infra.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  default_service: :class:`bool` or ``None``
        :param default_service: Fetch all default services (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.ServiceListResult`
        :return: com.vmware.nsx_policy.model.ServiceListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'cursor': cursor, 'default_service':
            default_service, 'include_mark_for_delete_objects':
            include_mark_for_delete_objects, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})

    def patch(self, service_id, service):
        """
        Create a new service if a service with the given ID does not already
        exist. Creates new service entries if populated in the service. If a
        service with the given ID already exists, patch the service including
        the nested service entries.

        :type  service_id: :class:`str`
        :param service_id: Service ID (required)
        :type  service: :class:`com.vmware.nsx_policy.model_client.Service`
        :param service: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch', {'service_id': service_id, 'service':
            service})

    def update(self, service_id, service):
        """
        Create a new service if a service with the given ID does not already
        exist. Creates new service entries if populated in the service. If a
        service with the given ID already exists, update the service including
        the nested service entries. This is a full replace.

        :type  service_id: :class:`str`
        :param service_id: Service ID (required)
        :type  service: :class:`com.vmware.nsx_policy.model_client.Service`
        :param service: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.Service`
        :return: com.vmware.nsx_policy.model.Service
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update', {'service_id': service_id, 'service':
            service})


class _DhcpRelayConfigsStub(ApiInterfaceStub):

    def __init__(self, config):
        delete_input_type = type.StructType('operation-input', {
            'dhcp_relay_config_id': type.StringType()})
        delete_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template=
            '/policy/api/v1/infra/dhcp-relay-configs/{dhcp-relay-config-id}',
            path_variables={'dhcp_relay_config_id': 'dhcp-relay-config-id'},
            query_parameters={}, content_type='application/json')
        get_input_type = type.StructType('operation-input', {
            'dhcp_relay_config_id': type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template=
            '/policy/api/v1/infra/dhcp-relay-configs/{dhcp-relay-config-id}',
            path_variables={'dhcp_relay_config_id': 'dhcp-relay-config-id'},
            query_parameters={}, content_type='application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/dhcp-relay-configs',
            path_variables={}, query_parameters={'cursor': 'cursor',
            'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        patch_input_type = type.StructType('operation-input', {
            'dhcp_relay_config_id': type.StringType(), 'dhcp_relay_config':
            type.ReferenceType('com.vmware.nsx_policy.model_client',
            'DhcpRelayConfig')})
        patch_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        patch_input_value_validator_list = [HasFieldsOfValidator()]
        patch_output_validator_list = []
        patch_rest_metadata = OperationRestMetadata(http_method='PATCH',
            url_template=
            '/policy/api/v1/infra/dhcp-relay-configs/{dhcp-relay-config-id}',
            request_body_parameter='dhcp_relay_config', path_variables={
            'dhcp_relay_config_id': 'dhcp-relay-config-id'},
            query_parameters={}, content_type='application/json')
        update_input_type = type.StructType('operation-input', {
            'dhcp_relay_config_id': type.StringType(), 'dhcp_relay_config':
            type.ReferenceType('com.vmware.nsx_policy.model_client',
            'DhcpRelayConfig')})
        update_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(http_method='PUT',
            url_template=
            '/policy/api/v1/infra/dhcp-relay-configs/{dhcp-relay-config-id}',
            request_body_parameter='dhcp_relay_config', path_variables={
            'dhcp_relay_config_id': 'dhcp-relay-config-id'},
            query_parameters={}, content_type='application/json')
        operations = {'delete': {'input_type': delete_input_type,
            'output_type': type.VoidType(), 'errors': delete_error_dict,
            'input_value_validator_list': delete_input_value_validator_list,
            'output_validator_list': delete_output_validator_list,
            'task_type': TaskType.NONE}, 'get': {'input_type':
            get_input_type, 'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'DhcpRelayConfig'),
            'errors': get_error_dict, 'input_value_validator_list':
            get_input_value_validator_list, 'output_validator_list':
            get_output_validator_list, 'task_type': TaskType.NONE}, 'list':
            {'input_type': list_input_type, 'output_type': type.
            ReferenceType('com.vmware.nsx_policy.model_client',
            'DhcpRelayConfigListResult'), 'errors': list_error_dict,
            'input_value_validator_list': list_input_value_validator_list,
            'output_validator_list': list_output_validator_list,
            'task_type': TaskType.NONE}, 'patch': {'input_type':
            patch_input_type, 'output_type': type.VoidType(), 'errors':
            patch_error_dict, 'input_value_validator_list':
            patch_input_value_validator_list, 'output_validator_list':
            patch_output_validator_list, 'task_type': TaskType.NONE},
            'update': {'input_type': update_input_type, 'output_type': type
            .ReferenceType('com.vmware.nsx_policy.model_client',
            'DhcpRelayConfig'), 'errors': update_error_dict,
            'input_value_validator_list': update_input_value_validator_list,
            'output_validator_list': update_output_validator_list,
            'task_type': TaskType.NONE}}
        rest_metadata = {'delete': delete_rest_metadata, 'get':
            get_rest_metadata, 'list': list_rest_metadata, 'patch':
            patch_rest_metadata, 'update': update_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.dhcp_relay_configs', config=config,
            operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)


class _DhcpServerConfigsStub(ApiInterfaceStub):

    def __init__(self, config):
        delete_input_type = type.StructType('operation-input', {
            'dhcp_server_config_id': type.StringType()})
        delete_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template=
            '/policy/api/v1/infra/dhcp-server-configs/{dhcp-server-config-id}',
            path_variables={'dhcp_server_config_id':
            'dhcp-server-config-id'}, query_parameters={}, content_type=
            'application/json')
        get_input_type = type.StructType('operation-input', {
            'dhcp_server_config_id': type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template=
            '/policy/api/v1/infra/dhcp-server-configs/{dhcp-server-config-id}',
            path_variables={'dhcp_server_config_id':
            'dhcp-server-config-id'}, query_parameters={}, content_type=
            'application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/dhcp-server-configs',
            path_variables={}, query_parameters={'cursor': 'cursor',
            'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        patch_input_type = type.StructType('operation-input', {
            'dhcp_server_config_id': type.StringType(),
            'dhcp_server_config': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'DhcpServerConfig')})
        patch_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        patch_input_value_validator_list = [HasFieldsOfValidator()]
        patch_output_validator_list = []
        patch_rest_metadata = OperationRestMetadata(http_method='PATCH',
            url_template=
            '/policy/api/v1/infra/dhcp-server-configs/{dhcp-server-config-id}',
            request_body_parameter='dhcp_server_config', path_variables={
            'dhcp_server_config_id': 'dhcp-server-config-id'},
            query_parameters={}, content_type='application/json')
        update_input_type = type.StructType('operation-input', {
            'dhcp_server_config_id': type.StringType(),
            'dhcp_server_config': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'DhcpServerConfig')})
        update_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(http_method='PUT',
            url_template=
            '/policy/api/v1/infra/dhcp-server-configs/{dhcp-server-config-id}',
            request_body_parameter='dhcp_server_config', path_variables={
            'dhcp_server_config_id': 'dhcp-server-config-id'},
            query_parameters={}, content_type='application/json')
        operations = {'delete': {'input_type': delete_input_type,
            'output_type': type.VoidType(), 'errors': delete_error_dict,
            'input_value_validator_list': delete_input_value_validator_list,
            'output_validator_list': delete_output_validator_list,
            'task_type': TaskType.NONE}, 'get': {'input_type':
            get_input_type, 'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'DhcpServerConfig'),
            'errors': get_error_dict, 'input_value_validator_list':
            get_input_value_validator_list, 'output_validator_list':
            get_output_validator_list, 'task_type': TaskType.NONE}, 'list':
            {'input_type': list_input_type, 'output_type': type.
            ReferenceType('com.vmware.nsx_policy.model_client',
            'DhcpServerConfigListResult'), 'errors': list_error_dict,
            'input_value_validator_list': list_input_value_validator_list,
            'output_validator_list': list_output_validator_list,
            'task_type': TaskType.NONE}, 'patch': {'input_type':
            patch_input_type, 'output_type': type.VoidType(), 'errors':
            patch_error_dict, 'input_value_validator_list':
            patch_input_value_validator_list, 'output_validator_list':
            patch_output_validator_list, 'task_type': TaskType.NONE},
            'update': {'input_type': update_input_type, 'output_type': type
            .ReferenceType('com.vmware.nsx_policy.model_client',
            'DhcpServerConfig'), 'errors': update_error_dict,
            'input_value_validator_list': update_input_value_validator_list,
            'output_validator_list': update_output_validator_list,
            'task_type': TaskType.NONE}}
        rest_metadata = {'delete': delete_rest_metadata, 'get':
            get_rest_metadata, 'list': list_rest_metadata, 'patch':
            patch_rest_metadata, 'update': update_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.dhcp_server_configs', config=
            config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)


class _DnsForwarderZonesStub(ApiInterfaceStub):

    def __init__(self, config):
        delete_input_type = type.StructType('operation-input', {
            'dns_forwarder_zone_id': type.StringType()})
        delete_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template=
            '/policy/api/v1/infra/dns-forwarder-zones/{dns-forwarder-zone-id}',
            path_variables={'dns_forwarder_zone_id':
            'dns-forwarder-zone-id'}, query_parameters={}, content_type=
            'application/json')
        get_input_type = type.StructType('operation-input', {
            'dns_forwarder_zone_id': type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template=
            '/policy/api/v1/infra/dns-forwarder-zones/{dns-forwarder-zone-id}',
            path_variables={'dns_forwarder_zone_id':
            'dns-forwarder-zone-id'}, query_parameters={}, content_type=
            'application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/dns-forwarder-zones',
            path_variables={}, query_parameters={'cursor': 'cursor',
            'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        patch_input_type = type.StructType('operation-input', {
            'dns_forwarder_zone_id': type.StringType(),
            'policy_dns_forwarder_zone': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'PolicyDnsForwarderZone')})
        patch_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        patch_input_value_validator_list = [HasFieldsOfValidator()]
        patch_output_validator_list = []
        patch_rest_metadata = OperationRestMetadata(http_method='PATCH',
            url_template=
            '/policy/api/v1/infra/dns-forwarder-zones/{dns-forwarder-zone-id}',
            request_body_parameter='policy_dns_forwarder_zone',
            path_variables={'dns_forwarder_zone_id':
            'dns-forwarder-zone-id'}, query_parameters={}, content_type=
            'application/json')
        update_input_type = type.StructType('operation-input', {
            'dns_forwarder_zone_id': type.StringType(),
            'policy_dns_forwarder_zone': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'PolicyDnsForwarderZone')})
        update_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(http_method='PUT',
            url_template=
            '/policy/api/v1/infra/dns-forwarder-zones/{dns-forwarder-zone-id}',
            request_body_parameter='policy_dns_forwarder_zone',
            path_variables={'dns_forwarder_zone_id':
            'dns-forwarder-zone-id'}, query_parameters={}, content_type=
            'application/json')
        operations = {'delete': {'input_type': delete_input_type,
            'output_type': type.VoidType(), 'errors': delete_error_dict,
            'input_value_validator_list': delete_input_value_validator_list,
            'output_validator_list': delete_output_validator_list,
            'task_type': TaskType.NONE}, 'get': {'input_type':
            get_input_type, 'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'PolicyDnsForwarderZone'),
            'errors': get_error_dict, 'input_value_validator_list':
            get_input_value_validator_list, 'output_validator_list':
            get_output_validator_list, 'task_type': TaskType.NONE}, 'list':
            {'input_type': list_input_type, 'output_type': type.
            ReferenceType('com.vmware.nsx_policy.model_client',
            'PolicyDnsForwarderZoneListResult'), 'errors': list_error_dict,
            'input_value_validator_list': list_input_value_validator_list,
            'output_validator_list': list_output_validator_list,
            'task_type': TaskType.NONE}, 'patch': {'input_type':
            patch_input_type, 'output_type': type.VoidType(), 'errors':
            patch_error_dict, 'input_value_validator_list':
            patch_input_value_validator_list, 'output_validator_list':
            patch_output_validator_list, 'task_type': TaskType.NONE},
            'update': {'input_type': update_input_type, 'output_type': type
            .ReferenceType('com.vmware.nsx_policy.model_client',
            'PolicyDnsForwarderZone'), 'errors': update_error_dict,
            'input_value_validator_list': update_input_value_validator_list,
            'output_validator_list': update_output_validator_list,
            'task_type': TaskType.NONE}}
        rest_metadata = {'delete': delete_rest_metadata, 'get':
            get_rest_metadata, 'list': list_rest_metadata, 'patch':
            patch_rest_metadata, 'update': update_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.dns_forwarder_zones', config=
            config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)


class _DomainsStub(ApiInterfaceStub):

    def __init__(self, config):
        get_input_type = type.StructType('operation-input', {'domain_id':
            type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/domains/{domain-id}',
            path_variables={'domain_id': 'domain-id'}, query_parameters={},
            content_type='application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/domains', path_variables={},
            query_parameters={'cursor': 'cursor',
            'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        operations = {'get': {'input_type': get_input_type, 'output_type':
            type.ReferenceType('com.vmware.nsx_policy.model_client',
            'Domain'), 'errors': get_error_dict,
            'input_value_validator_list': get_input_value_validator_list,
            'output_validator_list': get_output_validator_list, 'task_type':
            TaskType.NONE}, 'list': {'input_type': list_input_type,
            'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'DomainListResult'),
            'errors': list_error_dict, 'input_value_validator_list':
            list_input_value_validator_list, 'output_validator_list':
            list_output_validator_list, 'task_type': TaskType.NONE}}
        rest_metadata = {'get': get_rest_metadata, 'list': list_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.domains', config=config,
            operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)


class _DraftsStub(ApiInterfaceStub):

    def __init__(self, config):
        abort_input_type = type.StructType('operation-input', {'draft_id':
            type.StringType()})
        abort_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        abort_input_value_validator_list = []
        abort_output_validator_list = []
        abort_rest_metadata = OperationRestMetadata(http_method='POST',
            url_template=
            '/policy/api/v1/infra/drafts/{draft-id}?action=abort',
            path_variables={'draft_id': 'draft-id'}, query_parameters={},
            content_type='application/json')
        delete_input_type = type.StructType('operation-input', {'draft_id':
            type.StringType()})
        delete_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template='/policy/api/v1/infra/drafts/{draft-id}',
            path_variables={'draft_id': 'draft-id'}, query_parameters={},
            content_type='application/json')
        get_input_type = type.StructType('operation-input', {'draft_id':
            type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/drafts/{draft-id}',
            path_variables={'draft_id': 'draft-id'}, query_parameters={},
            content_type='application/json')
        list_input_type = type.StructType('operation-input', {'auto_drafts':
            type.OptionalType(type.BooleanType()), 'cursor': type.
            OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/drafts', path_variables={},
            query_parameters={'auto_drafts': 'auto_drafts', 'cursor':
            'cursor', 'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        patch_input_type = type.StructType('operation-input', {'draft_id':
            type.StringType(), 'policy_draft': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'PolicyDraft')})
        patch_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        patch_input_value_validator_list = [HasFieldsOfValidator()]
        patch_output_validator_list = []
        patch_rest_metadata = OperationRestMetadata(http_method='PATCH',
            url_template='/policy/api/v1/infra/drafts/{draft-id}',
            request_body_parameter='policy_draft', path_variables={
            'draft_id': 'draft-id'}, query_parameters={}, content_type=
            'application/json')
        publish_input_type = type.StructType('operation-input', {'draft_id':
            type.StringType(), 'infra': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'Infra')})
        publish_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        publish_input_value_validator_list = [HasFieldsOfValidator()]
        publish_output_validator_list = []
        publish_rest_metadata = OperationRestMetadata(http_method='POST',
            url_template=
            '/policy/api/v1/infra/drafts/{draft-id}?action=publish',
            request_body_parameter='infra', path_variables={'draft_id':
            'draft-id'}, query_parameters={}, content_type='application/json')
        update_input_type = type.StructType('operation-input', {'draft_id':
            type.StringType(), 'policy_draft': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'PolicyDraft')})
        update_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(http_method='PUT',
            url_template='/policy/api/v1/infra/drafts/{draft-id}',
            request_body_parameter='policy_draft', path_variables={
            'draft_id': 'draft-id'}, query_parameters={}, content_type=
            'application/json')
        operations = {'abort': {'input_type': abort_input_type,
            'output_type': type.VoidType(), 'errors': abort_error_dict,
            'input_value_validator_list': abort_input_value_validator_list,
            'output_validator_list': abort_output_validator_list,
            'task_type': TaskType.NONE}, 'delete': {'input_type':
            delete_input_type, 'output_type': type.VoidType(), 'errors':
            delete_error_dict, 'input_value_validator_list':
            delete_input_value_validator_list, 'output_validator_list':
            delete_output_validator_list, 'task_type': TaskType.NONE},
            'get': {'input_type': get_input_type, 'output_type': type.
            ReferenceType('com.vmware.nsx_policy.model_client',
            'PolicyDraft'), 'errors': get_error_dict,
            'input_value_validator_list': get_input_value_validator_list,
            'output_validator_list': get_output_validator_list, 'task_type':
            TaskType.NONE}, 'list': {'input_type': list_input_type,
            'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'PolicyDraftListResult'),
            'errors': list_error_dict, 'input_value_validator_list':
            list_input_value_validator_list, 'output_validator_list':
            list_output_validator_list, 'task_type': TaskType.NONE},
            'patch': {'input_type': patch_input_type, 'output_type': type.
            VoidType(), 'errors': patch_error_dict,
            'input_value_validator_list': patch_input_value_validator_list,
            'output_validator_list': patch_output_validator_list,
            'task_type': TaskType.NONE}, 'publish': {'input_type':
            publish_input_type, 'output_type': type.VoidType(), 'errors':
            publish_error_dict, 'input_value_validator_list':
            publish_input_value_validator_list, 'output_validator_list':
            publish_output_validator_list, 'task_type': TaskType.NONE},
            'update': {'input_type': update_input_type, 'output_type': type
            .ReferenceType('com.vmware.nsx_policy.model_client',
            'PolicyDraft'), 'errors': update_error_dict,
            'input_value_validator_list': update_input_value_validator_list,
            'output_validator_list': update_output_validator_list,
            'task_type': TaskType.NONE}}
        rest_metadata = {'abort': abort_rest_metadata, 'delete':
            delete_rest_metadata, 'get': get_rest_metadata, 'list':
            list_rest_metadata, 'patch': patch_rest_metadata, 'publish':
            publish_rest_metadata, 'update': update_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.drafts', config=config, operations
            =operations, rest_metadata=rest_metadata, is_vapi_rest=False)


class _GroupAssociationsStub(ApiInterfaceStub):

    def __init__(self, config):
        list_input_type = type.StructType('operation-input', {'intent_path':
            type.StringType(), 'cursor': type.OptionalType(type.StringType(
            )), 'enforcement_point_path': type.OptionalType(type.StringType
            ()), 'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = []
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/group-associations',
            path_variables={}, query_parameters={'intent_path':
            'intent_path', 'cursor': 'cursor', 'enforcement_point_path':
            'enforcement_point_path', 'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        operations = {'list': {'input_type': list_input_type, 'output_type':
            type.ReferenceType('com.vmware.nsx_policy.model_client',
            'PolicyResourceReferenceForEPListResult'), 'errors':
            list_error_dict, 'input_value_validator_list':
            list_input_value_validator_list, 'output_validator_list':
            list_output_validator_list, 'task_type': TaskType.NONE}}
        rest_metadata = {'list': list_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.group_associations', config=config,
            operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)


class _IpfixCollectorProfilesStub(ApiInterfaceStub):

    def __init__(self, config):
        delete_input_type = type.StructType('operation-input', {
            'ipfix_collector_profile_id': type.StringType()})
        delete_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template=
            '/policy/api/v1/infra/ipfix-collector-profiles/{ipfix-collector-profile-id}'
            , path_variables={'ipfix_collector_profile_id':
            'ipfix-collector-profile-id'}, query_parameters={},
            content_type='application/json')
        get_input_type = type.StructType('operation-input', {
            'ipfix_collector_profile_id': type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template=
            '/policy/api/v1/infra/ipfix-collector-profiles/{ipfix-collector-profile-id}'
            , path_variables={'ipfix_collector_profile_id':
            'ipfix-collector-profile-id'}, query_parameters={},
            content_type='application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/ipfix-collector-profiles',
            path_variables={}, query_parameters={'cursor': 'cursor',
            'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        patch_input_type = type.StructType('operation-input', {
            'ipfix_collector_profile_id': type.StringType(),
            'i_PFIX_collector_profile': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'IPFIXCollectorProfile')})
        patch_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        patch_input_value_validator_list = [HasFieldsOfValidator()]
        patch_output_validator_list = []
        patch_rest_metadata = OperationRestMetadata(http_method='PATCH',
            url_template=
            '/policy/api/v1/infra/ipfix-collector-profiles/{ipfix-collector-profile-id}'
            , request_body_parameter='i_PFIX_collector_profile',
            path_variables={'ipfix_collector_profile_id':
            'ipfix-collector-profile-id'}, query_parameters={},
            content_type='application/json')
        update_input_type = type.StructType('operation-input', {
            'ipfix_collector_profile_id': type.StringType(),
            'i_PFIX_collector_profile': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'IPFIXCollectorProfile')})
        update_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(http_method='PUT',
            url_template=
            '/policy/api/v1/infra/ipfix-collector-profiles/{ipfix-collector-profile-id}'
            , request_body_parameter='i_PFIX_collector_profile',
            path_variables={'ipfix_collector_profile_id':
            'ipfix-collector-profile-id'}, query_parameters={},
            content_type='application/json')
        operations = {'delete': {'input_type': delete_input_type,
            'output_type': type.VoidType(), 'errors': delete_error_dict,
            'input_value_validator_list': delete_input_value_validator_list,
            'output_validator_list': delete_output_validator_list,
            'task_type': TaskType.NONE}, 'get': {'input_type':
            get_input_type, 'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'IPFIXCollectorProfile'),
            'errors': get_error_dict, 'input_value_validator_list':
            get_input_value_validator_list, 'output_validator_list':
            get_output_validator_list, 'task_type': TaskType.NONE}, 'list':
            {'input_type': list_input_type, 'output_type': type.
            ReferenceType('com.vmware.nsx_policy.model_client',
            'IPFIXCollectorProfileListResult'), 'errors': list_error_dict,
            'input_value_validator_list': list_input_value_validator_list,
            'output_validator_list': list_output_validator_list,
            'task_type': TaskType.NONE}, 'patch': {'input_type':
            patch_input_type, 'output_type': type.VoidType(), 'errors':
            patch_error_dict, 'input_value_validator_list':
            patch_input_value_validator_list, 'output_validator_list':
            patch_output_validator_list, 'task_type': TaskType.NONE},
            'update': {'input_type': update_input_type, 'output_type': type
            .ReferenceType('com.vmware.nsx_policy.model_client',
            'IPFIXCollectorProfile'), 'errors': update_error_dict,
            'input_value_validator_list': update_input_value_validator_list,
            'output_validator_list': update_output_validator_list,
            'task_type': TaskType.NONE}}
        rest_metadata = {'delete': delete_rest_metadata, 'get':
            get_rest_metadata, 'list': list_rest_metadata, 'patch':
            patch_rest_metadata, 'update': update_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.ipfix_collector_profiles', config=
            config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)


class _IpfixDfwCollectorProfilesStub(ApiInterfaceStub):

    def __init__(self, config):
        delete_input_type = type.StructType('operation-input', {
            'ipfix_dfw_collector_profile_id': type.StringType()})
        delete_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template=
            '/policy/api/v1/infra/ipfix-dfw-collector-profiles/{ipfix-dfw-collector-profile-id}'
            , path_variables={'ipfix_dfw_collector_profile_id':
            'ipfix-dfw-collector-profile-id'}, query_parameters={},
            content_type='application/json')
        get_input_type = type.StructType('operation-input', {
            'ipfix_dfw_collector_profile_id': type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template=
            '/policy/api/v1/infra/ipfix-dfw-collector-profiles/{ipfix-dfw-collector-profile-id}'
            , path_variables={'ipfix_dfw_collector_profile_id':
            'ipfix-dfw-collector-profile-id'}, query_parameters={},
            content_type='application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template=
            '/policy/api/v1/infra/ipfix-dfw-collector-profiles',
            path_variables={}, query_parameters={'cursor': 'cursor',
            'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        patch_input_type = type.StructType('operation-input', {
            'ipfix_dfw_collector_profile_id': type.StringType(),
            'i_PFIXDFW_collector_profile': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'IPFIXDFWCollectorProfile')})
        patch_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        patch_input_value_validator_list = [HasFieldsOfValidator()]
        patch_output_validator_list = []
        patch_rest_metadata = OperationRestMetadata(http_method='PATCH',
            url_template=
            '/policy/api/v1/infra/ipfix-dfw-collector-profiles/{ipfix-dfw-collector-profile-id}'
            , request_body_parameter='i_PFIXDFW_collector_profile',
            path_variables={'ipfix_dfw_collector_profile_id':
            'ipfix-dfw-collector-profile-id'}, query_parameters={},
            content_type='application/json')
        update_input_type = type.StructType('operation-input', {
            'ipfix_dfw_collector_profile_id': type.StringType(),
            'i_PFIXDFW_collector_profile': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'IPFIXDFWCollectorProfile')})
        update_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(http_method='PUT',
            url_template=
            '/policy/api/v1/infra/ipfix-dfw-collector-profiles/{ipfix-dfw-collector-profile-id}'
            , request_body_parameter='i_PFIXDFW_collector_profile',
            path_variables={'ipfix_dfw_collector_profile_id':
            'ipfix-dfw-collector-profile-id'}, query_parameters={},
            content_type='application/json')
        operations = {'delete': {'input_type': delete_input_type,
            'output_type': type.VoidType(), 'errors': delete_error_dict,
            'input_value_validator_list': delete_input_value_validator_list,
            'output_validator_list': delete_output_validator_list,
            'task_type': TaskType.NONE}, 'get': {'input_type':
            get_input_type, 'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client',
            'IPFIXDFWCollectorProfile'), 'errors': get_error_dict,
            'input_value_validator_list': get_input_value_validator_list,
            'output_validator_list': get_output_validator_list, 'task_type':
            TaskType.NONE}, 'list': {'input_type': list_input_type,
            'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client',
            'IPFIXDFWCollectorProfileListResult'), 'errors':
            list_error_dict, 'input_value_validator_list':
            list_input_value_validator_list, 'output_validator_list':
            list_output_validator_list, 'task_type': TaskType.NONE},
            'patch': {'input_type': patch_input_type, 'output_type': type.
            VoidType(), 'errors': patch_error_dict,
            'input_value_validator_list': patch_input_value_validator_list,
            'output_validator_list': patch_output_validator_list,
            'task_type': TaskType.NONE}, 'update': {'input_type':
            update_input_type, 'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client',
            'IPFIXDFWCollectorProfile'), 'errors': update_error_dict,
            'input_value_validator_list': update_input_value_validator_list,
            'output_validator_list': update_output_validator_list,
            'task_type': TaskType.NONE}}
        rest_metadata = {'delete': delete_rest_metadata, 'get':
            get_rest_metadata, 'list': list_rest_metadata, 'patch':
            patch_rest_metadata, 'update': update_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.ipfix_dfw_collector_profiles',
            config=config, operations=operations, rest_metadata=
            rest_metadata, is_vapi_rest=False)


class _IpfixDfwProfilesStub(ApiInterfaceStub):

    def __init__(self, config):
        delete_input_type = type.StructType('operation-input', {
            'ipfix_dfw_profile_id': type.StringType()})
        delete_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template=
            '/policy/api/v1/infra/ipfix-dfw-profiles/{ipfix-dfw-profile-id}',
            path_variables={'ipfix_dfw_profile_id': 'ipfix-dfw-profile-id'},
            query_parameters={}, content_type='application/json')
        get_input_type = type.StructType('operation-input', {
            'ipfix_dfw_profile_id': type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template=
            '/policy/api/v1/infra/ipfix-dfw-profiles/{ipfix-dfw-profile-id}',
            path_variables={'ipfix_dfw_profile_id': 'ipfix-dfw-profile-id'},
            query_parameters={}, content_type='application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/ipfix-dfw-profiles',
            path_variables={}, query_parameters={'cursor': 'cursor',
            'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        patch_input_type = type.StructType('operation-input', {
            'ipfix_dfw_profile_id': type.StringType(), 'i_PFIXDFW_profile':
            type.ReferenceType('com.vmware.nsx_policy.model_client',
            'IPFIXDFWProfile')})
        patch_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        patch_input_value_validator_list = [HasFieldsOfValidator()]
        patch_output_validator_list = []
        patch_rest_metadata = OperationRestMetadata(http_method='PATCH',
            url_template=
            '/policy/api/v1/infra/ipfix-dfw-profiles/{ipfix-dfw-profile-id}',
            request_body_parameter='i_PFIXDFW_profile', path_variables={
            'ipfix_dfw_profile_id': 'ipfix-dfw-profile-id'},
            query_parameters={}, content_type='application/json')
        update_input_type = type.StructType('operation-input', {
            'ipfix_dfw_profile_id': type.StringType(), 'i_PFIXDFW_profile':
            type.ReferenceType('com.vmware.nsx_policy.model_client',
            'IPFIXDFWProfile')})
        update_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(http_method='PUT',
            url_template=
            '/policy/api/v1/infra/ipfix-dfw-profiles/{ipfix-dfw-profile-id}',
            request_body_parameter='i_PFIXDFW_profile', path_variables={
            'ipfix_dfw_profile_id': 'ipfix-dfw-profile-id'},
            query_parameters={}, content_type='application/json')
        operations = {'delete': {'input_type': delete_input_type,
            'output_type': type.VoidType(), 'errors': delete_error_dict,
            'input_value_validator_list': delete_input_value_validator_list,
            'output_validator_list': delete_output_validator_list,
            'task_type': TaskType.NONE}, 'get': {'input_type':
            get_input_type, 'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'IPFIXDFWProfile'),
            'errors': get_error_dict, 'input_value_validator_list':
            get_input_value_validator_list, 'output_validator_list':
            get_output_validator_list, 'task_type': TaskType.NONE}, 'list':
            {'input_type': list_input_type, 'output_type': type.
            ReferenceType('com.vmware.nsx_policy.model_client',
            'IPFIXDFWProfileListResult'), 'errors': list_error_dict,
            'input_value_validator_list': list_input_value_validator_list,
            'output_validator_list': list_output_validator_list,
            'task_type': TaskType.NONE}, 'patch': {'input_type':
            patch_input_type, 'output_type': type.VoidType(), 'errors':
            patch_error_dict, 'input_value_validator_list':
            patch_input_value_validator_list, 'output_validator_list':
            patch_output_validator_list, 'task_type': TaskType.NONE},
            'update': {'input_type': update_input_type, 'output_type': type
            .ReferenceType('com.vmware.nsx_policy.model_client',
            'IPFIXDFWProfile'), 'errors': update_error_dict,
            'input_value_validator_list': update_input_value_validator_list,
            'output_validator_list': update_output_validator_list,
            'task_type': TaskType.NONE}}
        rest_metadata = {'delete': delete_rest_metadata, 'get':
            get_rest_metadata, 'list': list_rest_metadata, 'patch':
            patch_rest_metadata, 'update': update_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.ipfix_dfw_profiles', config=config,
            operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)


class _IpfixL2CollectorProfilesStub(ApiInterfaceStub):

    def __init__(self, config):
        delete_input_type = type.StructType('operation-input', {
            'ipfix_l2_collector_profile_id': type.StringType()})
        delete_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template=
            '/policy/api/v1/infra/ipfix-l2-collector-profiles/{ipfix-l2-collector-profile-id}'
            , path_variables={'ipfix_l2_collector_profile_id':
            'ipfix-l2-collector-profile-id'}, query_parameters={},
            content_type='application/json')
        get_input_type = type.StructType('operation-input', {
            'ipfix_l2_collector_profile_id': type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template=
            '/policy/api/v1/infra/ipfix-l2-collector-profiles/{ipfix-l2-collector-profile-id}'
            , path_variables={'ipfix_l2_collector_profile_id':
            'ipfix-l2-collector-profile-id'}, query_parameters={},
            content_type='application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/ipfix-l2-collector-profiles',
            path_variables={}, query_parameters={'cursor': 'cursor',
            'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        patch_input_type = type.StructType('operation-input', {
            'ipfix_l2_collector_profile_id': type.StringType(),
            'i_PFIX_l2_collector_profile': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'IPFIXL2CollectorProfile')})
        patch_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        patch_input_value_validator_list = [HasFieldsOfValidator()]
        patch_output_validator_list = []
        patch_rest_metadata = OperationRestMetadata(http_method='PATCH',
            url_template=
            '/policy/api/v1/infra/ipfix-l2-collector-profiles/{ipfix-l2-collector-profile-id}'
            , request_body_parameter='i_PFIX_l2_collector_profile',
            path_variables={'ipfix_l2_collector_profile_id':
            'ipfix-l2-collector-profile-id'}, query_parameters={},
            content_type='application/json')
        update_input_type = type.StructType('operation-input', {
            'ipfix_l2_collector_profile_id': type.StringType(),
            'i_PFIX_l2_collector_profile': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'IPFIXL2CollectorProfile')})
        update_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(http_method='PUT',
            url_template=
            '/policy/api/v1/infra/ipfix-l2-collector-profiles/{ipfix-l2-collector-profile-id}'
            , request_body_parameter='i_PFIX_l2_collector_profile',
            path_variables={'ipfix_l2_collector_profile_id':
            'ipfix-l2-collector-profile-id'}, query_parameters={},
            content_type='application/json')
        operations = {'delete': {'input_type': delete_input_type,
            'output_type': type.VoidType(), 'errors': delete_error_dict,
            'input_value_validator_list': delete_input_value_validator_list,
            'output_validator_list': delete_output_validator_list,
            'task_type': TaskType.NONE}, 'get': {'input_type':
            get_input_type, 'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'IPFIXL2CollectorProfile'
            ), 'errors': get_error_dict, 'input_value_validator_list':
            get_input_value_validator_list, 'output_validator_list':
            get_output_validator_list, 'task_type': TaskType.NONE}, 'list':
            {'input_type': list_input_type, 'output_type': type.
            ReferenceType('com.vmware.nsx_policy.model_client',
            'IPFIXL2CollectorProfileListResult'), 'errors': list_error_dict,
            'input_value_validator_list': list_input_value_validator_list,
            'output_validator_list': list_output_validator_list,
            'task_type': TaskType.NONE}, 'patch': {'input_type':
            patch_input_type, 'output_type': type.VoidType(), 'errors':
            patch_error_dict, 'input_value_validator_list':
            patch_input_value_validator_list, 'output_validator_list':
            patch_output_validator_list, 'task_type': TaskType.NONE},
            'update': {'input_type': update_input_type, 'output_type': type
            .ReferenceType('com.vmware.nsx_policy.model_client',
            'IPFIXL2CollectorProfile'), 'errors': update_error_dict,
            'input_value_validator_list': update_input_value_validator_list,
            'output_validator_list': update_output_validator_list,
            'task_type': TaskType.NONE}}
        rest_metadata = {'delete': delete_rest_metadata, 'get':
            get_rest_metadata, 'list': list_rest_metadata, 'patch':
            patch_rest_metadata, 'update': update_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.ipfix_l2_collector_profiles',
            config=config, operations=operations, rest_metadata=
            rest_metadata, is_vapi_rest=False)


class _IpfixL2ProfilesStub(ApiInterfaceStub):

    def __init__(self, config):
        delete_input_type = type.StructType('operation-input', {
            'ipfix_l2_profile_id': type.StringType()})
        delete_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template=
            '/policy/api/v1/infra/ipfix-l2-profiles/{ipfix-l2-profile-id}',
            path_variables={'ipfix_l2_profile_id': 'ipfix-l2-profile-id'},
            query_parameters={}, content_type='application/json')
        get_input_type = type.StructType('operation-input', {
            'ipfix_l2_profile_id': type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template=
            '/policy/api/v1/infra/ipfix-l2-profiles/{ipfix-l2-profile-id}',
            path_variables={'ipfix_l2_profile_id': 'ipfix-l2-profile-id'},
            query_parameters={}, content_type='application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/ipfix-l2-profiles',
            path_variables={}, query_parameters={'cursor': 'cursor',
            'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        patch_input_type = type.StructType('operation-input', {
            'ipfix_l2_profile_id': type.StringType(), 'i_PFIX_l2_profile':
            type.ReferenceType('com.vmware.nsx_policy.model_client',
            'IPFIXL2Profile')})
        patch_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        patch_input_value_validator_list = [HasFieldsOfValidator()]
        patch_output_validator_list = []
        patch_rest_metadata = OperationRestMetadata(http_method='PATCH',
            url_template=
            '/policy/api/v1/infra/ipfix-l2-profiles/{ipfix-l2-profile-id}',
            request_body_parameter='i_PFIX_l2_profile', path_variables={
            'ipfix_l2_profile_id': 'ipfix-l2-profile-id'}, query_parameters
            ={}, content_type='application/json')
        update_input_type = type.StructType('operation-input', {
            'ipfix_l2_profile_id': type.StringType(), 'i_PFIX_l2_profile':
            type.ReferenceType('com.vmware.nsx_policy.model_client',
            'IPFIXL2Profile')})
        update_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(http_method='PUT',
            url_template=
            '/policy/api/v1/infra/ipfix-l2-profiles/{ipfix-l2-profile-id}',
            request_body_parameter='i_PFIX_l2_profile', path_variables={
            'ipfix_l2_profile_id': 'ipfix-l2-profile-id'}, query_parameters
            ={}, content_type='application/json')
        operations = {'delete': {'input_type': delete_input_type,
            'output_type': type.VoidType(), 'errors': delete_error_dict,
            'input_value_validator_list': delete_input_value_validator_list,
            'output_validator_list': delete_output_validator_list,
            'task_type': TaskType.NONE}, 'get': {'input_type':
            get_input_type, 'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'IPFIXL2Profile'),
            'errors': get_error_dict, 'input_value_validator_list':
            get_input_value_validator_list, 'output_validator_list':
            get_output_validator_list, 'task_type': TaskType.NONE}, 'list':
            {'input_type': list_input_type, 'output_type': type.
            ReferenceType('com.vmware.nsx_policy.model_client',
            'IPFIXL2ProfileListResult'), 'errors': list_error_dict,
            'input_value_validator_list': list_input_value_validator_list,
            'output_validator_list': list_output_validator_list,
            'task_type': TaskType.NONE}, 'patch': {'input_type':
            patch_input_type, 'output_type': type.VoidType(), 'errors':
            patch_error_dict, 'input_value_validator_list':
            patch_input_value_validator_list, 'output_validator_list':
            patch_output_validator_list, 'task_type': TaskType.NONE},
            'update': {'input_type': update_input_type, 'output_type': type
            .ReferenceType('com.vmware.nsx_policy.model_client',
            'IPFIXL2Profile'), 'errors': update_error_dict,
            'input_value_validator_list': update_input_value_validator_list,
            'output_validator_list': update_output_validator_list,
            'task_type': TaskType.NONE}}
        rest_metadata = {'delete': delete_rest_metadata, 'get':
            get_rest_metadata, 'list': list_rest_metadata, 'patch':
            patch_rest_metadata, 'update': update_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.ipfix_l2_profiles', config=config,
            operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)


class _IpsecVpnDpdProfilesStub(ApiInterfaceStub):

    def __init__(self, config):
        delete_input_type = type.StructType('operation-input', {
            'dpd_profile_id': type.StringType()})
        delete_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template=
            '/policy/api/v1/infra/ipsec-vpn-dpd-profiles/{dpd-profile-id}',
            path_variables={'dpd_profile_id': 'dpd-profile-id'},
            query_parameters={}, content_type='application/json')
        get_input_type = type.StructType('operation-input', {
            'dpd_profile_id': type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template=
            '/policy/api/v1/infra/ipsec-vpn-dpd-profiles/{dpd-profile-id}',
            path_variables={'dpd_profile_id': 'dpd-profile-id'},
            query_parameters={}, content_type='application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/ipsec-vpn-dpd-profiles',
            path_variables={}, query_parameters={'cursor': 'cursor',
            'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        patch_input_type = type.StructType('operation-input', {
            'dpd_profile_id': type.StringType(), 'ip_sec_vpn_dpd_profile':
            type.ReferenceType('com.vmware.nsx_policy.model_client',
            'IPSecVpnDpdProfile')})
        patch_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        patch_input_value_validator_list = [HasFieldsOfValidator()]
        patch_output_validator_list = []
        patch_rest_metadata = OperationRestMetadata(http_method='PATCH',
            url_template=
            '/policy/api/v1/infra/ipsec-vpn-dpd-profiles/{dpd-profile-id}',
            request_body_parameter='ip_sec_vpn_dpd_profile', path_variables
            ={'dpd_profile_id': 'dpd-profile-id'}, query_parameters={},
            content_type='application/json')
        update_input_type = type.StructType('operation-input', {
            'dpd_profile_id': type.StringType(), 'ip_sec_vpn_dpd_profile':
            type.ReferenceType('com.vmware.nsx_policy.model_client',
            'IPSecVpnDpdProfile')})
        update_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(http_method='PUT',
            url_template=
            '/policy/api/v1/infra/ipsec-vpn-dpd-profiles/{dpd-profile-id}',
            request_body_parameter='ip_sec_vpn_dpd_profile', path_variables
            ={'dpd_profile_id': 'dpd-profile-id'}, query_parameters={},
            content_type='application/json')
        operations = {'delete': {'input_type': delete_input_type,
            'output_type': type.VoidType(), 'errors': delete_error_dict,
            'input_value_validator_list': delete_input_value_validator_list,
            'output_validator_list': delete_output_validator_list,
            'task_type': TaskType.NONE}, 'get': {'input_type':
            get_input_type, 'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'IPSecVpnDpdProfile'),
            'errors': get_error_dict, 'input_value_validator_list':
            get_input_value_validator_list, 'output_validator_list':
            get_output_validator_list, 'task_type': TaskType.NONE}, 'list':
            {'input_type': list_input_type, 'output_type': type.
            ReferenceType('com.vmware.nsx_policy.model_client',
            'IPSecVpnDpdProfileListResult'), 'errors': list_error_dict,
            'input_value_validator_list': list_input_value_validator_list,
            'output_validator_list': list_output_validator_list,
            'task_type': TaskType.NONE}, 'patch': {'input_type':
            patch_input_type, 'output_type': type.VoidType(), 'errors':
            patch_error_dict, 'input_value_validator_list':
            patch_input_value_validator_list, 'output_validator_list':
            patch_output_validator_list, 'task_type': TaskType.NONE},
            'update': {'input_type': update_input_type, 'output_type': type
            .ReferenceType('com.vmware.nsx_policy.model_client',
            'IPSecVpnDpdProfile'), 'errors': update_error_dict,
            'input_value_validator_list': update_input_value_validator_list,
            'output_validator_list': update_output_validator_list,
            'task_type': TaskType.NONE}}
        rest_metadata = {'delete': delete_rest_metadata, 'get':
            get_rest_metadata, 'list': list_rest_metadata, 'patch':
            patch_rest_metadata, 'update': update_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.ipsec_vpn_dpd_profiles', config=
            config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)


class _IpsecVpnIkeProfilesStub(ApiInterfaceStub):

    def __init__(self, config):
        delete_input_type = type.StructType('operation-input', {
            'ike_profile_id': type.StringType()})
        delete_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template=
            '/policy/api/v1/infra/ipsec-vpn-ike-profiles/{ike-profile-id}',
            path_variables={'ike_profile_id': 'ike-profile-id'},
            query_parameters={}, content_type='application/json')
        get_input_type = type.StructType('operation-input', {
            'ike_profile_id': type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template=
            '/policy/api/v1/infra/ipsec-vpn-ike-profiles/{ike-profile-id}',
            path_variables={'ike_profile_id': 'ike-profile-id'},
            query_parameters={}, content_type='application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/ipsec-vpn-ike-profiles',
            path_variables={}, query_parameters={'cursor': 'cursor',
            'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        patch_input_type = type.StructType('operation-input', {
            'ike_profile_id': type.StringType(), 'ip_sec_vpn_ike_profile':
            type.ReferenceType('com.vmware.nsx_policy.model_client',
            'IPSecVpnIkeProfile')})
        patch_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        patch_input_value_validator_list = [HasFieldsOfValidator()]
        patch_output_validator_list = []
        patch_rest_metadata = OperationRestMetadata(http_method='PATCH',
            url_template=
            '/policy/api/v1/infra/ipsec-vpn-ike-profiles/{ike-profile-id}',
            request_body_parameter='ip_sec_vpn_ike_profile', path_variables
            ={'ike_profile_id': 'ike-profile-id'}, query_parameters={},
            content_type='application/json')
        update_input_type = type.StructType('operation-input', {
            'ike_profile_id': type.StringType(), 'ip_sec_vpn_ike_profile':
            type.ReferenceType('com.vmware.nsx_policy.model_client',
            'IPSecVpnIkeProfile')})
        update_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(http_method='PUT',
            url_template=
            '/policy/api/v1/infra/ipsec-vpn-ike-profiles/{ike-profile-id}',
            request_body_parameter='ip_sec_vpn_ike_profile', path_variables
            ={'ike_profile_id': 'ike-profile-id'}, query_parameters={},
            content_type='application/json')
        operations = {'delete': {'input_type': delete_input_type,
            'output_type': type.VoidType(), 'errors': delete_error_dict,
            'input_value_validator_list': delete_input_value_validator_list,
            'output_validator_list': delete_output_validator_list,
            'task_type': TaskType.NONE}, 'get': {'input_type':
            get_input_type, 'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'IPSecVpnIkeProfile'),
            'errors': get_error_dict, 'input_value_validator_list':
            get_input_value_validator_list, 'output_validator_list':
            get_output_validator_list, 'task_type': TaskType.NONE}, 'list':
            {'input_type': list_input_type, 'output_type': type.
            ReferenceType('com.vmware.nsx_policy.model_client',
            'IPSecVpnIkeProfileListResult'), 'errors': list_error_dict,
            'input_value_validator_list': list_input_value_validator_list,
            'output_validator_list': list_output_validator_list,
            'task_type': TaskType.NONE}, 'patch': {'input_type':
            patch_input_type, 'output_type': type.VoidType(), 'errors':
            patch_error_dict, 'input_value_validator_list':
            patch_input_value_validator_list, 'output_validator_list':
            patch_output_validator_list, 'task_type': TaskType.NONE},
            'update': {'input_type': update_input_type, 'output_type': type
            .ReferenceType('com.vmware.nsx_policy.model_client',
            'IPSecVpnIkeProfile'), 'errors': update_error_dict,
            'input_value_validator_list': update_input_value_validator_list,
            'output_validator_list': update_output_validator_list,
            'task_type': TaskType.NONE}}
        rest_metadata = {'delete': delete_rest_metadata, 'get':
            get_rest_metadata, 'list': list_rest_metadata, 'patch':
            patch_rest_metadata, 'update': update_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.ipsec_vpn_ike_profiles', config=
            config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)


class _IpsecVpnTunnelProfilesStub(ApiInterfaceStub):

    def __init__(self, config):
        delete_input_type = type.StructType('operation-input', {
            'tunnel_profile_id': type.StringType()})
        delete_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template=
            '/policy/api/v1/infra/ipsec-vpn-tunnel-profiles/{tunnel-profile-id}'
            , path_variables={'tunnel_profile_id': 'tunnel-profile-id'},
            query_parameters={}, content_type='application/json')
        get_input_type = type.StructType('operation-input', {
            'tunnel_profile_id': type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template=
            '/policy/api/v1/infra/ipsec-vpn-tunnel-profiles/{tunnel-profile-id}'
            , path_variables={'tunnel_profile_id': 'tunnel-profile-id'},
            query_parameters={}, content_type='application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/ipsec-vpn-tunnel-profiles',
            path_variables={}, query_parameters={'cursor': 'cursor',
            'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        patch_input_type = type.StructType('operation-input', {
            'tunnel_profile_id': type.StringType(),
            'ip_sec_vpn_tunnel_profile': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'IPSecVpnTunnelProfile')})
        patch_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        patch_input_value_validator_list = [HasFieldsOfValidator()]
        patch_output_validator_list = []
        patch_rest_metadata = OperationRestMetadata(http_method='PATCH',
            url_template=
            '/policy/api/v1/infra/ipsec-vpn-tunnel-profiles/{tunnel-profile-id}'
            , request_body_parameter='ip_sec_vpn_tunnel_profile',
            path_variables={'tunnel_profile_id': 'tunnel-profile-id'},
            query_parameters={}, content_type='application/json')
        update_input_type = type.StructType('operation-input', {
            'tunnel_profile_id': type.StringType(),
            'ip_sec_vpn_tunnel_profile': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'IPSecVpnTunnelProfile')})
        update_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(http_method='PUT',
            url_template=
            '/policy/api/v1/infra/ipsec-vpn-tunnel-profiles/{tunnel-profile-id}'
            , request_body_parameter='ip_sec_vpn_tunnel_profile',
            path_variables={'tunnel_profile_id': 'tunnel-profile-id'},
            query_parameters={}, content_type='application/json')
        operations = {'delete': {'input_type': delete_input_type,
            'output_type': type.VoidType(), 'errors': delete_error_dict,
            'input_value_validator_list': delete_input_value_validator_list,
            'output_validator_list': delete_output_validator_list,
            'task_type': TaskType.NONE}, 'get': {'input_type':
            get_input_type, 'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'IPSecVpnTunnelProfile'),
            'errors': get_error_dict, 'input_value_validator_list':
            get_input_value_validator_list, 'output_validator_list':
            get_output_validator_list, 'task_type': TaskType.NONE}, 'list':
            {'input_type': list_input_type, 'output_type': type.
            ReferenceType('com.vmware.nsx_policy.model_client',
            'IPSecVpnTunnelProfileListResult'), 'errors': list_error_dict,
            'input_value_validator_list': list_input_value_validator_list,
            'output_validator_list': list_output_validator_list,
            'task_type': TaskType.NONE}, 'patch': {'input_type':
            patch_input_type, 'output_type': type.VoidType(), 'errors':
            patch_error_dict, 'input_value_validator_list':
            patch_input_value_validator_list, 'output_validator_list':
            patch_output_validator_list, 'task_type': TaskType.NONE},
            'update': {'input_type': update_input_type, 'output_type': type
            .ReferenceType('com.vmware.nsx_policy.model_client',
            'IPSecVpnTunnelProfile'), 'errors': update_error_dict,
            'input_value_validator_list': update_input_value_validator_list,
            'output_validator_list': update_output_validator_list,
            'task_type': TaskType.NONE}}
        rest_metadata = {'delete': delete_rest_metadata, 'get':
            get_rest_metadata, 'list': list_rest_metadata, 'patch':
            patch_rest_metadata, 'update': update_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.ipsec_vpn_tunnel_profiles', config
            =config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)


class _PartnerServicesStub(ApiInterfaceStub):

    def __init__(self, config):
        get_input_type = type.StructType('operation-input', {'service_name':
            type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = []
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template=
            '/policy/api/v1/infra/partner-services/{service-name}',
            path_variables={'service_name': 'service-name'},
            query_parameters={}, content_type='application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = []
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/partner-services',
            path_variables={}, query_parameters={'cursor': 'cursor',
            'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        operations = {'get': {'input_type': get_input_type, 'output_type':
            type.ReferenceType('com.vmware.nsx_policy.model_client',
            'ServiceDefinition'), 'errors': get_error_dict,
            'input_value_validator_list': get_input_value_validator_list,
            'output_validator_list': get_output_validator_list, 'task_type':
            TaskType.NONE}, 'list': {'input_type': list_input_type,
            'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client',
            'ServiceInsertionServiceListResult'), 'errors': list_error_dict,
            'input_value_validator_list': list_input_value_validator_list,
            'output_validator_list': list_output_validator_list,
            'task_type': TaskType.NONE}}
        rest_metadata = {'get': get_rest_metadata, 'list': list_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.partner_services', config=config,
            operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)


class _PortMirroringProfilesStub(ApiInterfaceStub):

    def __init__(self, config):
        delete_input_type = type.StructType('operation-input', {
            'port_mirroring_profile_id': type.StringType()})
        delete_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template=
            '/policy/api/v1/infra/port-mirroring-profiles/{port-mirroring-profile-id}'
            , path_variables={'port_mirroring_profile_id':
            'port-mirroring-profile-id'}, query_parameters={}, content_type
            ='application/json')
        get_input_type = type.StructType('operation-input', {
            'port_mirroring_profile_id': type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template=
            '/policy/api/v1/infra/port-mirroring-profiles/{port-mirroring-profile-id}'
            , path_variables={'port_mirroring_profile_id':
            'port-mirroring-profile-id'}, query_parameters={}, content_type
            ='application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()), 'included_fields': type.
            OptionalType(type.StringType()), 'page_size': type.OptionalType
            (type.IntegerType()), 'sort_ascending': type.OptionalType(type.
            BooleanType()), 'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/port-mirroring-profiles',
            path_variables={}, query_parameters={'cursor': 'cursor',
            'included_fields': 'included_fields', 'page_size': 'page_size',
            'sort_ascending': 'sort_ascending', 'sort_by': 'sort_by'},
            content_type='application/json')
        patch_input_type = type.StructType('operation-input', {
            'port_mirroring_profile_id': type.StringType(),
            'port_mirroring_profile': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'PortMirroringProfile')})
        patch_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        patch_input_value_validator_list = [HasFieldsOfValidator()]
        patch_output_validator_list = []
        patch_rest_metadata = OperationRestMetadata(http_method='PATCH',
            url_template=
            '/policy/api/v1/infra/port-mirroring-profiles/{port-mirroring-profile-id}'
            , request_body_parameter='port_mirroring_profile',
            path_variables={'port_mirroring_profile_id':
            'port-mirroring-profile-id'}, query_parameters={}, content_type
            ='application/json')
        update_input_type = type.StructType('operation-input', {
            'port_mirroring_profile_id': type.StringType(),
            'port_mirroring_profile': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'PortMirroringProfile')})
        update_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(http_method='PUT',
            url_template=
            '/policy/api/v1/infra/port-mirroring-profiles/{port-mirroring-profile-id}'
            , request_body_parameter='port_mirroring_profile',
            path_variables={'port_mirroring_profile_id':
            'port-mirroring-profile-id'}, query_parameters={}, content_type
            ='application/json')
        operations = {'delete': {'input_type': delete_input_type,
            'output_type': type.VoidType(), 'errors': delete_error_dict,
            'input_value_validator_list': delete_input_value_validator_list,
            'output_validator_list': delete_output_validator_list,
            'task_type': TaskType.NONE}, 'get': {'input_type':
            get_input_type, 'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'PortMirroringProfile'),
            'errors': get_error_dict, 'input_value_validator_list':
            get_input_value_validator_list, 'output_validator_list':
            get_output_validator_list, 'task_type': TaskType.NONE}, 'list':
            {'input_type': list_input_type, 'output_type': type.
            ReferenceType('com.vmware.nsx_policy.model_client',
            'PortMirroringProfileListResult'), 'errors': list_error_dict,
            'input_value_validator_list': list_input_value_validator_list,
            'output_validator_list': list_output_validator_list,
            'task_type': TaskType.NONE}, 'patch': {'input_type':
            patch_input_type, 'output_type': type.VoidType(), 'errors':
            patch_error_dict, 'input_value_validator_list':
            patch_input_value_validator_list, 'output_validator_list':
            patch_output_validator_list, 'task_type': TaskType.NONE},
            'update': {'input_type': update_input_type, 'output_type': type
            .ReferenceType('com.vmware.nsx_policy.model_client',
            'PortMirroringProfile'), 'errors': update_error_dict,
            'input_value_validator_list': update_input_value_validator_list,
            'output_validator_list': update_output_validator_list,
            'task_type': TaskType.NONE}}
        rest_metadata = {'delete': delete_rest_metadata, 'get':
            get_rest_metadata, 'list': list_rest_metadata, 'patch':
            patch_rest_metadata, 'update': update_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.port_mirroring_profiles', config=
            config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)


class _SegmentsStub(ApiInterfaceStub):

    def __init__(self, config):
        delete_input_type = type.StructType('operation-input', {
            'segment_id': type.StringType()})
        delete_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template='/policy/api/v1/infra/segments/{segment-id}',
            path_variables={'segment_id': 'segment-id'}, query_parameters={
            }, content_type='application/json')
        delete_0_input_type = type.StructType('operation-input', {
            'segment_id': type.StringType()})
        delete_0_error_dict = {'com.vmware.vapi.std.errors.service_unavailable'
            : type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_0_input_value_validator_list = []
        delete_0_output_validator_list = []
        delete_0_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template=
            '/policy/api/v1/infra/segments/{segment-id}?force=true',
            path_variables={'segment_id': 'segment-id'}, query_parameters={
            }, content_type='application/json')
        get_input_type = type.StructType('operation-input', {'segment_id':
            type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/segments/{segment-id}',
            path_variables={'segment_id': 'segment-id'}, query_parameters={
            }, content_type='application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/segments', path_variables={},
            query_parameters={'cursor': 'cursor',
            'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        patch_input_type = type.StructType('operation-input', {'segment_id':
            type.StringType(), 'segment': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'Segment')})
        patch_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        patch_input_value_validator_list = [HasFieldsOfValidator()]
        patch_output_validator_list = []
        patch_rest_metadata = OperationRestMetadata(http_method='PATCH',
            url_template='/policy/api/v1/infra/segments/{segment-id}',
            request_body_parameter='segment', path_variables={'segment_id':
            'segment-id'}, query_parameters={}, content_type='application/json'
            )
        update_input_type = type.StructType('operation-input', {
            'segment_id': type.StringType(), 'segment': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'Segment')})
        update_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(http_method='PUT',
            url_template='/policy/api/v1/infra/segments/{segment-id}',
            request_body_parameter='segment', path_variables={'segment_id':
            'segment-id'}, query_parameters={}, content_type='application/json'
            )
        operations = {'delete': {'input_type': delete_input_type,
            'output_type': type.VoidType(), 'errors': delete_error_dict,
            'input_value_validator_list': delete_input_value_validator_list,
            'output_validator_list': delete_output_validator_list,
            'task_type': TaskType.NONE}, 'delete_0': {'input_type':
            delete_0_input_type, 'output_type': type.VoidType(), 'errors':
            delete_0_error_dict, 'input_value_validator_list':
            delete_0_input_value_validator_list, 'output_validator_list':
            delete_0_output_validator_list, 'task_type': TaskType.NONE},
            'get': {'input_type': get_input_type, 'output_type': type.
            ReferenceType('com.vmware.nsx_policy.model_client', 'Segment'),
            'errors': get_error_dict, 'input_value_validator_list':
            get_input_value_validator_list, 'output_validator_list':
            get_output_validator_list, 'task_type': TaskType.NONE}, 'list':
            {'input_type': list_input_type, 'output_type': type.
            ReferenceType('com.vmware.nsx_policy.model_client',
            'SegmentListResult'), 'errors': list_error_dict,
            'input_value_validator_list': list_input_value_validator_list,
            'output_validator_list': list_output_validator_list,
            'task_type': TaskType.NONE}, 'patch': {'input_type':
            patch_input_type, 'output_type': type.VoidType(), 'errors':
            patch_error_dict, 'input_value_validator_list':
            patch_input_value_validator_list, 'output_validator_list':
            patch_output_validator_list, 'task_type': TaskType.NONE},
            'update': {'input_type': update_input_type, 'output_type': type
            .ReferenceType('com.vmware.nsx_policy.model_client', 'Segment'),
            'errors': update_error_dict, 'input_value_validator_list':
            update_input_value_validator_list, 'output_validator_list':
            update_output_validator_list, 'task_type': TaskType.NONE}}
        rest_metadata = {'delete': delete_rest_metadata, 'delete_0':
            delete_0_rest_metadata, 'get': get_rest_metadata, 'list':
            list_rest_metadata, 'patch': patch_rest_metadata, 'update':
            update_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.segments', config=config,
            operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)


class _ServicesStub(ApiInterfaceStub):

    def __init__(self, config):
        delete_input_type = type.StructType('operation-input', {
            'service_id': type.StringType()})
        delete_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template='/policy/api/v1/infra/services/{service-id}',
            path_variables={'service_id': 'service-id'}, query_parameters={
            }, content_type='application/json')
        get_input_type = type.StructType('operation-input', {'service_id':
            type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/services/{service-id}',
            path_variables={'service_id': 'service-id'}, query_parameters={
            }, content_type='application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()), 'default_service': type.
            OptionalType(type.BooleanType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/services', path_variables={},
            query_parameters={'cursor': 'cursor', 'default_service':
            'default_service', 'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        patch_input_type = type.StructType('operation-input', {'service_id':
            type.StringType(), 'service': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'Service')})
        patch_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        patch_input_value_validator_list = [HasFieldsOfValidator()]
        patch_output_validator_list = []
        patch_rest_metadata = OperationRestMetadata(http_method='PATCH',
            url_template='/policy/api/v1/infra/services/{service-id}',
            request_body_parameter='service', path_variables={'service_id':
            'service-id'}, query_parameters={}, content_type='application/json'
            )
        update_input_type = type.StructType('operation-input', {
            'service_id': type.StringType(), 'service': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'Service')})
        update_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(http_method='PUT',
            url_template='/policy/api/v1/infra/services/{service-id}',
            request_body_parameter='service', path_variables={'service_id':
            'service-id'}, query_parameters={}, content_type='application/json'
            )
        operations = {'delete': {'input_type': delete_input_type,
            'output_type': type.VoidType(), 'errors': delete_error_dict,
            'input_value_validator_list': delete_input_value_validator_list,
            'output_validator_list': delete_output_validator_list,
            'task_type': TaskType.NONE}, 'get': {'input_type':
            get_input_type, 'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'Service'), 'errors':
            get_error_dict, 'input_value_validator_list':
            get_input_value_validator_list, 'output_validator_list':
            get_output_validator_list, 'task_type': TaskType.NONE}, 'list':
            {'input_type': list_input_type, 'output_type': type.
            ReferenceType('com.vmware.nsx_policy.model_client',
            'ServiceListResult'), 'errors': list_error_dict,
            'input_value_validator_list': list_input_value_validator_list,
            'output_validator_list': list_output_validator_list,
            'task_type': TaskType.NONE}, 'patch': {'input_type':
            patch_input_type, 'output_type': type.VoidType(), 'errors':
            patch_error_dict, 'input_value_validator_list':
            patch_input_value_validator_list, 'output_validator_list':
            patch_output_validator_list, 'task_type': TaskType.NONE},
            'update': {'input_type': update_input_type, 'output_type': type
            .ReferenceType('com.vmware.nsx_policy.model_client', 'Service'),
            'errors': update_error_dict, 'input_value_validator_list':
            update_input_value_validator_list, 'output_validator_list':
            update_output_validator_list, 'task_type': TaskType.NONE}}
        rest_metadata = {'delete': delete_rest_metadata, 'get':
            get_rest_metadata, 'list': list_rest_metadata, 'patch':
            patch_rest_metadata, 'update': update_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.services', config=config,
            operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)


class StubFactory(StubFactoryBase):
    _attrs = {'DhcpRelayConfigs': DhcpRelayConfigs, 'DhcpServerConfigs':
        DhcpServerConfigs, 'DnsForwarderZones': DnsForwarderZones,
        'Domains': Domains, 'Drafts': Drafts, 'GroupAssociations':
        GroupAssociations, 'IpfixCollectorProfiles': IpfixCollectorProfiles,
        'IpfixDfwCollectorProfiles': IpfixDfwCollectorProfiles,
        'IpfixDfwProfiles': IpfixDfwProfiles, 'IpfixL2CollectorProfiles':
        IpfixL2CollectorProfiles, 'IpfixL2Profiles': IpfixL2Profiles,
        'IpsecVpnDpdProfiles': IpsecVpnDpdProfiles, 'IpsecVpnIkeProfiles':
        IpsecVpnIkeProfiles, 'IpsecVpnTunnelProfiles':
        IpsecVpnTunnelProfiles, 'PartnerServices': PartnerServices,
        'PortMirroringProfiles': PortMirroringProfiles, 'Segments':
        Segments, 'Services': Services, 'domains':
        'com.vmware.nsx_policy.infra.domains_client.StubFactory', 'drafts':
        'com.vmware.nsx_policy.infra.drafts_client.StubFactory',
        'realized_state':
        'com.vmware.nsx_policy.infra.realized_state_client.StubFactory',
        'segments':
        'com.vmware.nsx_policy.infra.segments_client.StubFactory',
        'services':
        'com.vmware.nsx_policy.infra.services_client.StubFactory', 'sites':
        'com.vmware.nsx_policy.infra.sites_client.StubFactory', 'tier_0s':
        'com.vmware.nsx_policy.infra.tier_0s_client.StubFactory', 'tier_1s':
        'com.vmware.nsx_policy.infra.tier_1s_client.StubFactory'}

<mask token>


class DhcpServerConfigs(VapiInterface):
    <mask token>
    <mask token>
    <mask token>

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _DhcpServerConfigsStub)
        self._VAPI_OPERATION_IDS = {}

    def delete(self, dhcp_server_config_id):
        """
        Delete DHCP server configuration

        :type  dhcp_server_config_id: :class:`str`
        :param dhcp_server_config_id: DHCP server config ID (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete', {'dhcp_server_config_id':
            dhcp_server_config_id})

    def get(self, dhcp_server_config_id):
        """
        Read DHCP server configuration

        :type  dhcp_server_config_id: :class:`str`
        :param dhcp_server_config_id: DHCP server config ID (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.DhcpServerConfig`
        :return: com.vmware.nsx_policy.model.DhcpServerConfig
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'dhcp_server_config_id':
            dhcp_server_config_id})
    <mask token>

    def patch(self, dhcp_server_config_id, dhcp_server_config):
        """
        If DHCP server config with the dhcp-server-config-id is not already
        present, create a new DHCP server config instance. If it already
        exists, update the DHCP server config instance with specified
        attributes. Realized entities of this API can be found using the path
        of Tier-0 that this config is applied on.

        :type  dhcp_server_config_id: :class:`str`
        :param dhcp_server_config_id: DHCP server config ID (required)
        :type  dhcp_server_config: :class:`com.vmware.nsx_policy.model_client.DhcpServerConfig`
        :param dhcp_server_config: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch', {'dhcp_server_config_id':
            dhcp_server_config_id, 'dhcp_server_config': dhcp_server_config})

    def update(self, dhcp_server_config_id, dhcp_server_config):
        """
        If DHCP server config with the dhcp-server-config-id is not already
        present, create a new DHCP server config instance. If it already
        exists, replace the DHCP server config instance with this object.
        Realized entities of this API can be found using the path of Tier-0
        that this config is applied on.

        :type  dhcp_server_config_id: :class:`str`
        :param dhcp_server_config_id: DHCP server config ID (required)
        :type  dhcp_server_config: :class:`com.vmware.nsx_policy.model_client.DhcpServerConfig`
        :param dhcp_server_config: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.DhcpServerConfig`
        :return: com.vmware.nsx_policy.model.DhcpServerConfig
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update', {'dhcp_server_config_id':
            dhcp_server_config_id, 'dhcp_server_config': dhcp_server_config})


class DnsForwarderZones(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.dns_forwarder_zones'
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _DnsForwarderZonesStub)
        self._VAPI_OPERATION_IDS = {}

    def delete(self, dns_forwarder_zone_id):
        """
        Delete the DNS Forwarder Zone

        :type  dns_forwarder_zone_id: :class:`str`
        :param dns_forwarder_zone_id: DNS Forwarder Zone ID (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete', {'dns_forwarder_zone_id':
            dns_forwarder_zone_id})

    def get(self, dns_forwarder_zone_id):
        """
        Read the DNS Forwarder Zone

        :type  dns_forwarder_zone_id: :class:`str`
        :param dns_forwarder_zone_id: DNS Forwarder Zone ID (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.PolicyDnsForwarderZone`
        :return: com.vmware.nsx_policy.model.PolicyDnsForwarderZone
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'dns_forwarder_zone_id':
            dns_forwarder_zone_id})

    def list(self, cursor=None, include_mark_for_delete_objects=None,
        included_fields=None, page_size=None, sort_ascending=None, sort_by=None
        ):
        """
        Paginated list of all Dns Forwarder Zones

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.PolicyDnsForwarderZoneListResult`
        :return: com.vmware.nsx_policy.model.PolicyDnsForwarderZoneListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'cursor': cursor,
            'include_mark_for_delete_objects':
            include_mark_for_delete_objects, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})

    def patch(self, dns_forwarder_zone_id, policy_dns_forwarder_zone):
        """
        Create or update the DNS Forwarder Zone

        :type  dns_forwarder_zone_id: :class:`str`
        :param dns_forwarder_zone_id: DNS Forwarder Zone ID (required)
        :type  policy_dns_forwarder_zone: :class:`com.vmware.nsx_policy.model_client.PolicyDnsForwarderZone`
        :param policy_dns_forwarder_zone: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch', {'dns_forwarder_zone_id':
            dns_forwarder_zone_id, 'policy_dns_forwarder_zone':
            policy_dns_forwarder_zone})

    def update(self, dns_forwarder_zone_id, policy_dns_forwarder_zone):
        """
        Create or update the DNS Forwarder Zone

        :type  dns_forwarder_zone_id: :class:`str`
        :param dns_forwarder_zone_id: DNS Forwarder Zone ID (required)
        :type  policy_dns_forwarder_zone: :class:`com.vmware.nsx_policy.model_client.PolicyDnsForwarderZone`
        :param policy_dns_forwarder_zone: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.PolicyDnsForwarderZone`
        :return: com.vmware.nsx_policy.model.PolicyDnsForwarderZone
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update', {'dns_forwarder_zone_id':
            dns_forwarder_zone_id, 'policy_dns_forwarder_zone':
            policy_dns_forwarder_zone})


class Domains(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.domains'
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _DomainsStub)
        self._VAPI_OPERATION_IDS = {}

    def get(self, domain_id):
        """
        Read a domain.

        :type  domain_id: :class:`str`
        :param domain_id: Domain ID (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.Domain`
        :return: com.vmware.nsx_policy.model.Domain
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'domain_id': domain_id})

    def list(self, cursor=None, include_mark_for_delete_objects=None,
        included_fields=None, page_size=None, sort_ascending=None, sort_by=None
        ):
        """
        Paginated list of all domains for infra.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.DomainListResult`
        :return: com.vmware.nsx_policy.model.DomainListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'cursor': cursor,
            'include_mark_for_delete_objects':
            include_mark_for_delete_objects, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})


class Drafts(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.drafts'
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _DraftsStub)
        self._VAPI_OPERATION_IDS = {}

    def abort(self, draft_id):
        """
        If there is a failure during publish, the admin can choose to abort the
        publishing attempts. This will bring back the system to the current
        configuration, i.e just before the publish was invoked. If draft
        publishing is not in progress or already completed, then this is a
        NO-OP

        :type  draft_id: :class:`str`
        :param draft_id: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('abort', {'draft_id': draft_id})

    def delete(self, draft_id):
        """
        Delete a manual draft.

        :type  draft_id: :class:`str`
        :param draft_id: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete', {'draft_id': draft_id})

    def get(self, draft_id):
        """
        Read a draft for a given draft identifier.

        :type  draft_id: :class:`str`
        :param draft_id: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.PolicyDraft`
        :return: com.vmware.nsx_policy.model.PolicyDraft
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'draft_id': draft_id})

    def list(self, auto_drafts=None, cursor=None,
        include_mark_for_delete_objects=None, included_fields=None,
        page_size=None, sort_ascending=None, sort_by=None):
        """
        List policy drafts.

        :type  auto_drafts: :class:`bool` or ``None``
        :param auto_drafts: Fetch list of draft based on is_auto_draft flag (optional)
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.PolicyDraftListResult`
        :return: com.vmware.nsx_policy.model.PolicyDraftListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'auto_drafts': auto_drafts, 'cursor':
            cursor, 'include_mark_for_delete_objects':
            include_mark_for_delete_objects, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})

    def patch(self, draft_id, policy_draft):
        """
        Create a new manual draft if the specified draft id does not correspond
        to an existing draft. Update the manual draft otherwise. Auto draft can
        not be updated.

        :type  draft_id: :class:`str`
        :param draft_id: (required)
        :type  policy_draft: :class:`com.vmware.nsx_policy.model_client.PolicyDraft`
        :param policy_draft: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch', {'draft_id': draft_id, 'policy_draft':
            policy_draft})

    def publish(self, draft_id, infra):
        """
        Read a draft and publish it by applying changes onto current
        configuration.

        :type  draft_id: :class:`str`
        :param draft_id: (required)
        :type  infra: :class:`com.vmware.nsx_policy.model_client.Infra`
        :param infra: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('publish', {'draft_id': draft_id, 'infra': infra})

    def update(self, draft_id, policy_draft):
        """
        Create a new manual draft if the specified draft id does not correspond
        to an existing draft. Update the manual draft otherwise. Auto draft can
        not be updated.

        :type  draft_id: :class:`str`
        :param draft_id: (required)
        :type  policy_draft: :class:`com.vmware.nsx_policy.model_client.PolicyDraft`
        :param policy_draft: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.PolicyDraft`
        :return: com.vmware.nsx_policy.model.PolicyDraft
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update', {'draft_id': draft_id, 'policy_draft':
            policy_draft})


class GroupAssociations(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.group_associations'
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _GroupAssociationsStub)
        self._VAPI_OPERATION_IDS = {}

    def list(self, intent_path, cursor=None, enforcement_point_path=None,
        include_mark_for_delete_objects=None, included_fields=None,
        page_size=None, sort_ascending=None, sort_by=None):
        """
        Get policy groups for which the given object is a member.

        :type  intent_path: :class:`str`
        :param intent_path: String path of the intent object (required)
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  enforcement_point_path: :class:`str` or ``None``
        :param enforcement_point_path: String Path of the enforcement point (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.PolicyResourceReferenceForEPListResult`
        :return: com.vmware.nsx_policy.model.PolicyResourceReferenceForEPListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'intent_path': intent_path, 'cursor':
            cursor, 'enforcement_point_path': enforcement_point_path,
            'include_mark_for_delete_objects':
            include_mark_for_delete_objects, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})


class IpfixCollectorProfiles(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.ipfix_collector_profiles'
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _IpfixCollectorProfilesStub)
        self._VAPI_OPERATION_IDS = {}

    def delete(self, ipfix_collector_profile_id):
        """
        API deletes IPFIX collector profile. Flow forwarding to collector will
        be stopped. This API is deprecated. Please use the following API:
        https://<policy-mgr>/policy/api/v1/infra/ipfix-l2-collector-profiles

        :type  ipfix_collector_profile_id: :class:`str`
        :param ipfix_collector_profile_id: IPFIX collector Profile id (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete', {'ipfix_collector_profile_id':
            ipfix_collector_profile_id})

    def get(self, ipfix_collector_profile_id):
        """
        API will return details of IPFIX collector profile. If profile does not
        exist, it will return 404. This API is deprecated. Please use the
        following API:
        https://<policy-mgr>/policy/api/v1/infra/ipfix-l2-collector-profiles

        :type  ipfix_collector_profile_id: :class:`str`
        :param ipfix_collector_profile_id: IPFIX collector profile id (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXCollectorProfile`
        :return: com.vmware.nsx_policy.model.IPFIXCollectorProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'ipfix_collector_profile_id':
            ipfix_collector_profile_id})

    def list(self, cursor=None, include_mark_for_delete_objects=None,
        included_fields=None, page_size=None, sort_ascending=None, sort_by=None
        ):
        """
        API will provide list of all IPFIX collector profiles and their
        details. This API is deprecated. Please use the following API:
        https://<policy-mgr>/policy/api/v1/infra/ipfix-l2-collector-profiles

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXCollectorProfileListResult`
        :return: com.vmware.nsx_policy.model.IPFIXCollectorProfileListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'cursor': cursor,
            'include_mark_for_delete_objects':
            include_mark_for_delete_objects, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})

    def patch(self, ipfix_collector_profile_id, i_pfix_collector_profile):
        """
        Create a new IPFIX collector profile if the IPFIX collector profile
        with given id does not already exist. If the IPFIX collector profile
        with the given id already exists, patch with the existing IPFIX
        collector profile. This API is deprecated. Please use the following
        API:
        https://<policy-mgr>/policy/api/v1/infra/ipfix-l2-collector-profiles

        :type  ipfix_collector_profile_id: :class:`str`
        :param ipfix_collector_profile_id: IPFIX collector profile id (required)
        :type  i_pfix_collector_profile: :class:`com.vmware.nsx_policy.model_client.IPFIXCollectorProfile`
        :param i_pfix_collector_profile: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch', {'ipfix_collector_profile_id':
            ipfix_collector_profile_id, 'i_pfix_collector_profile':
            i_pfix_collector_profile})

    def update(self, ipfix_collector_profile_id, i_pfix_collector_profile):
        """
        Create or Replace IPFIX collector profile. IPFIX data will be sent to
        IPFIX collector port. This API is deprecated. Please use the following
        API:
        https://<policy-mgr>/policy/api/v1/infra/ipfix-l2-collector-profiles

        :type  ipfix_collector_profile_id: :class:`str`
        :param ipfix_collector_profile_id: IPFIX collector profile id (required)
        :type  i_pfix_collector_profile: :class:`com.vmware.nsx_policy.model_client.IPFIXCollectorProfile`
        :param i_pfix_collector_profile: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXCollectorProfile`
        :return: com.vmware.nsx_policy.model.IPFIXCollectorProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update', {'ipfix_collector_profile_id':
            ipfix_collector_profile_id, 'i_pfix_collector_profile':
            i_pfix_collector_profile})


class IpfixDfwCollectorProfiles(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = (
        'com.vmware.nsx_policy.infra.ipfix_dfw_collector_profiles')
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _IpfixDfwCollectorProfilesStub)
        self._VAPI_OPERATION_IDS = {}

    def delete(self, ipfix_dfw_collector_profile_id):
        """
        API deletes IPFIX dfw collector profile. Flow forwarding to collector
        will be stopped.

        :type  ipfix_dfw_collector_profile_id: :class:`str`
        :param ipfix_dfw_collector_profile_id: IPFIX dfw collector Profile id (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete', {'ipfix_dfw_collector_profile_id':
            ipfix_dfw_collector_profile_id})

    def get(self, ipfix_dfw_collector_profile_id):
        """
        API will return details of IPFIX dfw collector profile. If profile does
        not exist, it will return 404.

        :type  ipfix_dfw_collector_profile_id: :class:`str`
        :param ipfix_dfw_collector_profile_id: IPFIX dfw collector profile id (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXDFWCollectorProfile`
        :return: com.vmware.nsx_policy.model.IPFIXDFWCollectorProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'ipfix_dfw_collector_profile_id':
            ipfix_dfw_collector_profile_id})

    def list(self, cursor=None, include_mark_for_delete_objects=None,
        included_fields=None, page_size=None, sort_ascending=None, sort_by=None
        ):
        """
        API will provide list of all IPFIX dfw collector profiles and their
        details.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXDFWCollectorProfileListResult`
        :return: com.vmware.nsx_policy.model.IPFIXDFWCollectorProfileListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'cursor': cursor,
            'include_mark_for_delete_objects':
            include_mark_for_delete_objects, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})

    def patch(self, ipfix_dfw_collector_profile_id, i_pfixdfw_collector_profile
        ):
        """
        Create a new IPFIX dfw collector profile if the IPFIX dfw collector
        profile with given id does not already exist. If the IPFIX dfw
        collector profile with the given id already exists, patch with the
        existing IPFIX dfw collector profile.

        :type  ipfix_dfw_collector_profile_id: :class:`str`
        :param ipfix_dfw_collector_profile_id: (required)
        :type  i_pfixdfw_collector_profile: :class:`com.vmware.nsx_policy.model_client.IPFIXDFWCollectorProfile`
        :param i_pfixdfw_collector_profile: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch', {'ipfix_dfw_collector_profile_id':
            ipfix_dfw_collector_profile_id, 'i_pfixdfw_collector_profile':
            i_pfixdfw_collector_profile})

    def update(self, ipfix_dfw_collector_profile_id,
        i_pfixdfw_collector_profile):
        """
        Create or Replace IPFIX dfw collector profile. IPFIX data will be sent
        to IPFIX collector port.

        :type  ipfix_dfw_collector_profile_id: :class:`str`
        :param ipfix_dfw_collector_profile_id: IPFIX dfw collector profile id (required)
        :type  i_pfixdfw_collector_profile: :class:`com.vmware.nsx_policy.model_client.IPFIXDFWCollectorProfile`
        :param i_pfixdfw_collector_profile: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXDFWCollectorProfile`
        :return: com.vmware.nsx_policy.model.IPFIXDFWCollectorProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update', {'ipfix_dfw_collector_profile_id':
            ipfix_dfw_collector_profile_id, 'i_pfixdfw_collector_profile':
            i_pfixdfw_collector_profile})


class IpfixDfwProfiles(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.ipfix_dfw_profiles'
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _IpfixDfwProfilesStub)
        self._VAPI_OPERATION_IDS = {}

    def delete(self, ipfix_dfw_profile_id):
        """
        API deletes IPFIX DFW Profile. Selected IPFIX Collectors will stop
        receiving flows.

        :type  ipfix_dfw_profile_id: :class:`str`
        :param ipfix_dfw_profile_id: IPFIX DFW Profile ID (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete', {'ipfix_dfw_profile_id':
            ipfix_dfw_profile_id})

    def get(self, ipfix_dfw_profile_id):
        """
        API will return details of IPFIX DFW profile.

        :type  ipfix_dfw_profile_id: :class:`str`
        :param ipfix_dfw_profile_id: IPFIX DFW collection id (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXDFWProfile`
        :return: com.vmware.nsx_policy.model.IPFIXDFWProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'ipfix_dfw_profile_id':
            ipfix_dfw_profile_id})

    def list(self, cursor=None, include_mark_for_delete_objects=None,
        included_fields=None, page_size=None, sort_ascending=None, sort_by=None
        ):
        """
        API provides list IPFIX DFW profiles available on selected logical DFW.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXDFWProfileListResult`
        :return: com.vmware.nsx_policy.model.IPFIXDFWProfileListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'cursor': cursor,
            'include_mark_for_delete_objects':
            include_mark_for_delete_objects, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})

    def patch(self, ipfix_dfw_profile_id, i_pfixdfw_profile):
        """
        Create a new IPFIX DFW profile if the IPFIX DFW profile with given id
        does not already exist. If the IPFIX DFW profile with the given id
        already exists, patch with the existing IPFIX DFW profile.

        :type  ipfix_dfw_profile_id: :class:`str`
        :param ipfix_dfw_profile_id: IPFIX DFW Profile ID (required)
        :type  i_pfixdfw_profile: :class:`com.vmware.nsx_policy.model_client.IPFIXDFWProfile`
        :param i_pfixdfw_profile: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch', {'ipfix_dfw_profile_id':
            ipfix_dfw_profile_id, 'i_pfixdfw_profile': i_pfixdfw_profile})

    def update(self, ipfix_dfw_profile_id, i_pfixdfw_profile):
        """
        Create or replace IPFIX DFW profile. Config will start forwarding data
        to provided IPFIX DFW collector.

        :type  ipfix_dfw_profile_id: :class:`str`
        :param ipfix_dfw_profile_id: IPFIX DFW Profile ID (required)
        :type  i_pfixdfw_profile: :class:`com.vmware.nsx_policy.model_client.IPFIXDFWProfile`
        :param i_pfixdfw_profile: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXDFWProfile`
        :return: com.vmware.nsx_policy.model.IPFIXDFWProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update', {'ipfix_dfw_profile_id':
            ipfix_dfw_profile_id, 'i_pfixdfw_profile': i_pfixdfw_profile})


class IpfixL2CollectorProfiles(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = (
        'com.vmware.nsx_policy.infra.ipfix_l2_collector_profiles')
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _IpfixL2CollectorProfilesStub)
        self._VAPI_OPERATION_IDS = {}

    def delete(self, ipfix_l2_collector_profile_id):
        """
        API deletes IPFIX collector profile. Flow forwarding to collector will
        be stopped.

        :type  ipfix_l2_collector_profile_id: :class:`str`
        :param ipfix_l2_collector_profile_id: IPFIX collector Profile id (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete', {'ipfix_l2_collector_profile_id':
            ipfix_l2_collector_profile_id})

    def get(self, ipfix_l2_collector_profile_id):
        """
        API will return details of IPFIX collector profile.

        :type  ipfix_l2_collector_profile_id: :class:`str`
        :param ipfix_l2_collector_profile_id: IPFIX collector profile id (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXL2CollectorProfile`
        :return: com.vmware.nsx_policy.model.IPFIXL2CollectorProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'ipfix_l2_collector_profile_id':
            ipfix_l2_collector_profile_id})

    def list(self, cursor=None, include_mark_for_delete_objects=None,
        included_fields=None, page_size=None, sort_ascending=None, sort_by=None
        ):
        """
        API will provide list of all IPFIX collector profiles and their
        details.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXL2CollectorProfileListResult`
        :return: com.vmware.nsx_policy.model.IPFIXL2CollectorProfileListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'cursor': cursor,
            'include_mark_for_delete_objects':
            include_mark_for_delete_objects, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})

    def patch(self, ipfix_l2_collector_profile_id, i_pfix_l2_collector_profile
        ):
        """
        Create a new IPFIX collector profile if the IPFIX collector profile
        with given id does not already exist. If the IPFIX collector profile
        with the given id already exists, patch with the existing IPFIX
        collector profile.

        :type  ipfix_l2_collector_profile_id: :class:`str`
        :param ipfix_l2_collector_profile_id: IPFIX collector profile id (required)
        :type  i_pfix_l2_collector_profile: :class:`com.vmware.nsx_policy.model_client.IPFIXL2CollectorProfile`
        :param i_pfix_l2_collector_profile: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch', {'ipfix_l2_collector_profile_id':
            ipfix_l2_collector_profile_id, 'i_pfix_l2_collector_profile':
            i_pfix_l2_collector_profile})

    def update(self, ipfix_l2_collector_profile_id, i_pfix_l2_collector_profile
        ):
        """
        Create or Replace IPFIX collector profile. IPFIX data will be sent to
        IPFIX collector.

        :type  ipfix_l2_collector_profile_id: :class:`str`
        :param ipfix_l2_collector_profile_id: IPFIX collector profile id (required)
        :type  i_pfix_l2_collector_profile: :class:`com.vmware.nsx_policy.model_client.IPFIXL2CollectorProfile`
        :param i_pfix_l2_collector_profile: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXL2CollectorProfile`
        :return: com.vmware.nsx_policy.model.IPFIXL2CollectorProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update', {'ipfix_l2_collector_profile_id':
            ipfix_l2_collector_profile_id, 'i_pfix_l2_collector_profile':
            i_pfix_l2_collector_profile})


class IpfixL2Profiles(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.ipfix_l2_profiles'
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _IpfixL2ProfilesStub)
        self._VAPI_OPERATION_IDS = {}

    def delete(self, ipfix_l2_profile_id):
        """
        API deletes IPFIX L2 Profile. Flow forwarding to selected collector
        will be stopped.

        :type  ipfix_l2_profile_id: :class:`str`
        :param ipfix_l2_profile_id: IPFIX L2 Profile ID (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete', {'ipfix_l2_profile_id':
            ipfix_l2_profile_id})

    def get(self, ipfix_l2_profile_id):
        """
        API will return details of IPFIX L2 profile.

        :type  ipfix_l2_profile_id: :class:`str`
        :param ipfix_l2_profile_id: IPFIX L2 profile id (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXL2Profile`
        :return: com.vmware.nsx_policy.model.IPFIXL2Profile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'ipfix_l2_profile_id': ipfix_l2_profile_id}
            )

    def list(self, cursor=None, include_mark_for_delete_objects=None,
        included_fields=None, page_size=None, sort_ascending=None, sort_by=None
        ):
        """
        API provides list IPFIX L2 Profiles available on selected logical l2.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXL2ProfileListResult`
        :return: com.vmware.nsx_policy.model.IPFIXL2ProfileListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'cursor': cursor,
            'include_mark_for_delete_objects':
            include_mark_for_delete_objects, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})

    def patch(self, ipfix_l2_profile_id, i_pfix_l2_profile):
        """
        Create a new IPFIX L2 profile if the IPFIX L2 profile with given id
        does not already exist. If the IPFIX L2 profile with the given id
        already exists, patch with the existing IPFIX L2 profile.

        :type  ipfix_l2_profile_id: :class:`str`
        :param ipfix_l2_profile_id: IPFIX L2 Profile ID (required)
        :type  i_pfix_l2_profile: :class:`com.vmware.nsx_policy.model_client.IPFIXL2Profile`
        :param i_pfix_l2_profile: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch', {'ipfix_l2_profile_id':
            ipfix_l2_profile_id, 'i_pfix_l2_profile': i_pfix_l2_profile})

    def update(self, ipfix_l2_profile_id, i_pfix_l2_profile):
        """
        Create or replace IPFIX L2 Profile. Profile is reusable entity. Single
        profile can attached multiple bindings e.g group, segment and port.

        :type  ipfix_l2_profile_id: :class:`str`
        :param ipfix_l2_profile_id: IPFIX L2 Profile ID (required)
        :type  i_pfix_l2_profile: :class:`com.vmware.nsx_policy.model_client.IPFIXL2Profile`
        :param i_pfix_l2_profile: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXL2Profile`
        :return: com.vmware.nsx_policy.model.IPFIXL2Profile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update', {'ipfix_l2_profile_id':
            ipfix_l2_profile_id, 'i_pfix_l2_profile': i_pfix_l2_profile})


class IpsecVpnDpdProfiles(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.ipsec_vpn_dpd_profiles'
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _IpsecVpnDpdProfilesStub)
        self._VAPI_OPERATION_IDS = {}

    def delete(self, dpd_profile_id):
        """
        Delete custom dead peer detection (DPD) profile. Profile can not be
        deleted if profile has references to it.

        :type  dpd_profile_id: :class:`str`
        :param dpd_profile_id: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete', {'dpd_profile_id': dpd_profile_id})

    def get(self, dpd_profile_id):
        """
        Get custom dead peer detection (DPD) profile, given the particular id.

        :type  dpd_profile_id: :class:`str`
        :param dpd_profile_id: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPSecVpnDpdProfile`
        :return: com.vmware.nsx_policy.model.IPSecVpnDpdProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'dpd_profile_id': dpd_profile_id})

    def list(self, cursor=None, include_mark_for_delete_objects=None,
        included_fields=None, page_size=None, sort_ascending=None, sort_by=None
        ):
        """
        Get paginated list of all DPD Profiles.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPSecVpnDpdProfileListResult`
        :return: com.vmware.nsx_policy.model.IPSecVpnDpdProfileListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'cursor': cursor,
            'include_mark_for_delete_objects':
            include_mark_for_delete_objects, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})

    def patch(self, dpd_profile_id, ip_sec_vpn_dpd_profile):
        """
        Create or patch dead peer detection (DPD) profile. Any change in
        profile affects all sessions consuming this profile. System will be
        provisioned with system owned editable default DPD profile. Any change
        in profile affects all sessions consuming this profile.

        :type  dpd_profile_id: :class:`str`
        :param dpd_profile_id: (required)
        :type  ip_sec_vpn_dpd_profile: :class:`com.vmware.nsx_policy.model_client.IPSecVpnDpdProfile`
        :param ip_sec_vpn_dpd_profile: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch', {'dpd_profile_id': dpd_profile_id,
            'ip_sec_vpn_dpd_profile': ip_sec_vpn_dpd_profile})

    def update(self, dpd_profile_id, ip_sec_vpn_dpd_profile):
        """
        Create or patch dead peer detection (DPD) profile. Any change in
        profile affects all sessions consuming this profile. System will be
        provisioned with system owned editable default DPD profile. Any change
        in profile affects all sessions consuming this profile. Revision is
        optional for creation and required for update.

        :type  dpd_profile_id: :class:`str`
        :param dpd_profile_id: (required)
        :type  ip_sec_vpn_dpd_profile: :class:`com.vmware.nsx_policy.model_client.IPSecVpnDpdProfile`
        :param ip_sec_vpn_dpd_profile: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPSecVpnDpdProfile`
        :return: com.vmware.nsx_policy.model.IPSecVpnDpdProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update', {'dpd_profile_id': dpd_profile_id,
            'ip_sec_vpn_dpd_profile': ip_sec_vpn_dpd_profile})


class IpsecVpnIkeProfiles(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.ipsec_vpn_ike_profiles'
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _IpsecVpnIkeProfilesStub)
        self._VAPI_OPERATION_IDS = {}

    def delete(self, ike_profile_id):
        """
        Delete custom IKE Profile. Profile can not be deleted if profile has
        references to it.

        :type  ike_profile_id: :class:`str`
        :param ike_profile_id: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete', {'ike_profile_id': ike_profile_id})

    def get(self, ike_profile_id):
        """
        Get custom IKE Profile, given the particular id.

        :type  ike_profile_id: :class:`str`
        :param ike_profile_id: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPSecVpnIkeProfile`
        :return: com.vmware.nsx_policy.model.IPSecVpnIkeProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'ike_profile_id': ike_profile_id})

    def list(self, cursor=None, include_mark_for_delete_objects=None,
        included_fields=None, page_size=None, sort_ascending=None, sort_by=None
        ):
        """
        Get paginated list of all IKE Profiles.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPSecVpnIkeProfileListResult`
        :return: com.vmware.nsx_policy.model.IPSecVpnIkeProfileListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'cursor': cursor,
            'include_mark_for_delete_objects':
            include_mark_for_delete_objects, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})

    def patch(self, ike_profile_id, ip_sec_vpn_ike_profile):
        """
        Create or patch custom internet key exchange (IKE) Profile. IKE Profile
        is a reusable profile that captures IKE and phase one negotiation
        parameters. System will be pre provisioned with system owned editable
        default IKE profile and suggested set of profiles that can be used for
        peering with popular remote peers like AWS VPN. User can create custom
        profiles as needed. Any change in profile affects all sessions
        consuming this profile.

        :type  ike_profile_id: :class:`str`
        :param ike_profile_id: (required)
        :type  ip_sec_vpn_ike_profile: :class:`com.vmware.nsx_policy.model_client.IPSecVpnIkeProfile`
        :param ip_sec_vpn_ike_profile: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch', {'ike_profile_id': ike_profile_id,
            'ip_sec_vpn_ike_profile': ip_sec_vpn_ike_profile})

    def update(self, ike_profile_id, ip_sec_vpn_ike_profile):
        """
        Create or fully replace custom internet key exchange (IKE) Profile. IKE
        Profile is a reusable profile that captures IKE and phase one
        negotiation parameters. System will be pre provisioned with system
        owned editable default IKE profile and suggested set of profiles that
        can be used for peering with popular remote peers like AWS VPN. User
        can create custom profiles as needed. Any change in profile affects all
        sessions consuming this profile. Revision is optional for creation and
        required for update.

        :type  ike_profile_id: :class:`str`
        :param ike_profile_id: (required)
        :type  ip_sec_vpn_ike_profile: :class:`com.vmware.nsx_policy.model_client.IPSecVpnIkeProfile`
        :param ip_sec_vpn_ike_profile: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPSecVpnIkeProfile`
        :return: com.vmware.nsx_policy.model.IPSecVpnIkeProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update', {'ike_profile_id': ike_profile_id,
            'ip_sec_vpn_ike_profile': ip_sec_vpn_ike_profile})


class IpsecVpnTunnelProfiles(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.ipsec_vpn_tunnel_profiles'
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _IpsecVpnTunnelProfilesStub)
        self._VAPI_OPERATION_IDS = {}

    def delete(self, tunnel_profile_id):
        """
        Delete custom IPSec tunnel Profile. Profile can not be deleted if
        profile has references to it.

        :type  tunnel_profile_id: :class:`str`
        :param tunnel_profile_id: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete', {'tunnel_profile_id': tunnel_profile_id})

    def get(self, tunnel_profile_id):
        """
        Get custom IPSec tunnel Profile, given the particular id.

        :type  tunnel_profile_id: :class:`str`
        :param tunnel_profile_id: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPSecVpnTunnelProfile`
        :return: com.vmware.nsx_policy.model.IPSecVpnTunnelProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'tunnel_profile_id': tunnel_profile_id})

    def list(self, cursor=None, include_mark_for_delete_objects=None,
        included_fields=None, page_size=None, sort_ascending=None, sort_by=None
        ):
        """
        Get paginated list of all IPSec tunnel Profiles.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPSecVpnTunnelProfileListResult`
        :return: com.vmware.nsx_policy.model.IPSecVpnTunnelProfileListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'cursor': cursor,
            'include_mark_for_delete_objects':
            include_mark_for_delete_objects, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})

    def patch(self, tunnel_profile_id, ip_sec_vpn_tunnel_profile):
        """
        Create or patch custom IPSec tunnel profile. IPSec tunnel profile is a
        reusable profile that captures phase two negotiation parameters and
        tunnel properties. System will be provisioned with system owned
        editable default IPSec tunnel profile. Any change in profile affects
        all sessions consuming this profile.

        :type  tunnel_profile_id: :class:`str`
        :param tunnel_profile_id: (required)
        :type  ip_sec_vpn_tunnel_profile: :class:`com.vmware.nsx_policy.model_client.IPSecVpnTunnelProfile`
        :param ip_sec_vpn_tunnel_profile: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch', {'tunnel_profile_id':
            tunnel_profile_id, 'ip_sec_vpn_tunnel_profile':
            ip_sec_vpn_tunnel_profile})

    def update(self, tunnel_profile_id, ip_sec_vpn_tunnel_profile):
        """
        Create or fully replace custom IPSec tunnel profile. IPSec tunnel
        profile is a reusable profile that captures phase two negotiation
        parameters and tunnel properties. System will be provisioned with
        system owned editable default IPSec tunnel profile. Any change in
        profile affects all sessions consuming this profile. Revision is
        optional for creation and required for update.

        :type  tunnel_profile_id: :class:`str`
        :param tunnel_profile_id: (required)
        :type  ip_sec_vpn_tunnel_profile: :class:`com.vmware.nsx_policy.model_client.IPSecVpnTunnelProfile`
        :param ip_sec_vpn_tunnel_profile: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPSecVpnTunnelProfile`
        :return: com.vmware.nsx_policy.model.IPSecVpnTunnelProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update', {'tunnel_profile_id':
            tunnel_profile_id, 'ip_sec_vpn_tunnel_profile':
            ip_sec_vpn_tunnel_profile})


class PartnerServices(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.partner_services'
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _PartnerServicesStub)
        self._VAPI_OPERATION_IDS = {}

    def get(self, service_name):
        """
        Read the specific partner service identified by provided name.

        :type  service_name: :class:`str`
        :param service_name: Name of the service (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.ServiceDefinition`
        :return: com.vmware.nsx_policy.model.ServiceDefinition
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'service_name': service_name})

    def list(self, cursor=None, include_mark_for_delete_objects=None,
        included_fields=None, page_size=None, sort_ascending=None, sort_by=None
        ):
        """
        Read all the partner services available for service insertion

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.ServiceInsertionServiceListResult`
        :return: com.vmware.nsx_policy.model.ServiceInsertionServiceListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'cursor': cursor,
            'include_mark_for_delete_objects':
            include_mark_for_delete_objects, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})


class PortMirroringProfiles(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.port_mirroring_profiles'
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _PortMirroringProfilesStub)
        self._VAPI_OPERATION_IDS = {}

    def delete(self, port_mirroring_profile_id):
        """
        API will delete port mirroring profile. Mirroring from source to
        destination ports will be stopped.

        :type  port_mirroring_profile_id: :class:`str`
        :param port_mirroring_profile_id: Port Mirroring Profile Id (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete', {'port_mirroring_profile_id':
            port_mirroring_profile_id})

    def get(self, port_mirroring_profile_id):
        """
        API will return details of port mirroring profile.

        :type  port_mirroring_profile_id: :class:`str`
        :param port_mirroring_profile_id: Port Mirroring Profile Id (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.PortMirroringProfile`
        :return: com.vmware.nsx_policy.model.PortMirroringProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'port_mirroring_profile_id':
            port_mirroring_profile_id})

    def list(self, cursor=None, included_fields=None, page_size=None,
        sort_ascending=None, sort_by=None):
        """
        API will list all port mirroring profiles group.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.PortMirroringProfileListResult`
        :return: com.vmware.nsx_policy.model.PortMirroringProfileListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'cursor': cursor, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})

    def patch(self, port_mirroring_profile_id, port_mirroring_profile):
        """
        Create a new Port Mirroring Profile if the Port Mirroring Profile with
        given id does not already exist. If the Port Mirroring Profile with the
        given id already exists, patch with the existing Port Mirroring
        Profile. Realized entities of this API can be found using the path of
        monitoring profile binding map that is used to apply this profile.

        :type  port_mirroring_profile_id: :class:`str`
        :param port_mirroring_profile_id: Port Mirroring Profile Id (required)
        :type  port_mirroring_profile: :class:`com.vmware.nsx_policy.model_client.PortMirroringProfile`
        :param port_mirroring_profile: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch', {'port_mirroring_profile_id':
            port_mirroring_profile_id, 'port_mirroring_profile':
            port_mirroring_profile})

    def update(self, port_mirroring_profile_id, port_mirroring_profile):
        """
        Create or Replace port mirroring profile. Packets will be mirrored from
        source group, segment, port to destination group. Realized entities of
        this API can be found using the path of monitoring profile binding map
        that is used to apply this profile.

        :type  port_mirroring_profile_id: :class:`str`
        :param port_mirroring_profile_id: Port Mirroring Profiles Id (required)
        :type  port_mirroring_profile: :class:`com.vmware.nsx_policy.model_client.PortMirroringProfile`
        :param port_mirroring_profile: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.PortMirroringProfile`
        :return: com.vmware.nsx_policy.model.PortMirroringProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update', {'port_mirroring_profile_id':
            port_mirroring_profile_id, 'port_mirroring_profile':
            port_mirroring_profile})


class Segments(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.segments'
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _SegmentsStub)
        self._VAPI_OPERATION_IDS = {}

    def delete(self, segment_id):
        """
        Delete infra segment

        :type  segment_id: :class:`str`
        :param segment_id: Segment ID (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete', {'segment_id': segment_id})

    def delete_0(self, segment_id):
        """
        Force delete bypasses validations during segment deletion. This may
        result in an inconsistent connectivity.

        :type  segment_id: :class:`str`
        :param segment_id: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete_0', {'segment_id': segment_id})

    def get(self, segment_id):
        """
        Read infra segment

        :type  segment_id: :class:`str`
        :param segment_id: Segment ID (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.Segment`
        :return: com.vmware.nsx_policy.model.Segment
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'segment_id': segment_id})

    def list(self, cursor=None, include_mark_for_delete_objects=None,
        included_fields=None, page_size=None, sort_ascending=None, sort_by=None
        ):
        """
        Paginated list of all segments under infra.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.SegmentListResult`
        :return: com.vmware.nsx_policy.model.SegmentListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'cursor': cursor,
            'include_mark_for_delete_objects':
            include_mark_for_delete_objects, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})

    def patch(self, segment_id, segment):
        """
        If segment with the segment-id is not already present, create a new
        segment. If it already exists, update the segment with specified
        attributes.

        :type  segment_id: :class:`str`
        :param segment_id: Segment ID (required)
        :type  segment: :class:`com.vmware.nsx_policy.model_client.Segment`
        :param segment: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch', {'segment_id': segment_id, 'segment':
            segment})

    def update(self, segment_id, segment):
        """
        If segment with the segment-id is not already present, create a new
        segment. If it already exists, replace the segment with this object.

        :type  segment_id: :class:`str`
        :param segment_id: Segment ID (required)
        :type  segment: :class:`com.vmware.nsx_policy.model_client.Segment`
        :param segment: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.Segment`
        :return: com.vmware.nsx_policy.model.Segment
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update', {'segment_id': segment_id, 'segment':
            segment})


class Services(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.services'
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _ServicesStub)
        self._VAPI_OPERATION_IDS = {}

    def delete(self, service_id):
        """
        Delete Service

        :type  service_id: :class:`str`
        :param service_id: Service ID (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete', {'service_id': service_id})

    def get(self, service_id):
        """
        Read a service

        :type  service_id: :class:`str`
        :param service_id: Service ID (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.Service`
        :return: com.vmware.nsx_policy.model.Service
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'service_id': service_id})

    def list(self, cursor=None, default_service=None,
        include_mark_for_delete_objects=None, included_fields=None,
        page_size=None, sort_ascending=None, sort_by=None):
        """
        Paginated list of Services for infra.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  default_service: :class:`bool` or ``None``
        :param default_service: Fetch all default services (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.ServiceListResult`
        :return: com.vmware.nsx_policy.model.ServiceListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'cursor': cursor, 'default_service':
            default_service, 'include_mark_for_delete_objects':
            include_mark_for_delete_objects, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})

    def patch(self, service_id, service):
        """
        Create a new service if a service with the given ID does not already
        exist. Creates new service entries if populated in the service. If a
        service with the given ID already exists, patch the service including
        the nested service entries.

        :type  service_id: :class:`str`
        :param service_id: Service ID (required)
        :type  service: :class:`com.vmware.nsx_policy.model_client.Service`
        :param service: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch', {'service_id': service_id, 'service':
            service})

    def update(self, service_id, service):
        """
        Create a new service if a service with the given ID does not already
        exist. Creates new service entries if populated in the service. If a
        service with the given ID already exists, update the service including
        the nested service entries. This is a full replace.

        :type  service_id: :class:`str`
        :param service_id: Service ID (required)
        :type  service: :class:`com.vmware.nsx_policy.model_client.Service`
        :param service: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.Service`
        :return: com.vmware.nsx_policy.model.Service
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update', {'service_id': service_id, 'service':
            service})


class _DhcpRelayConfigsStub(ApiInterfaceStub):

    def __init__(self, config):
        delete_input_type = type.StructType('operation-input', {
            'dhcp_relay_config_id': type.StringType()})
        delete_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template=
            '/policy/api/v1/infra/dhcp-relay-configs/{dhcp-relay-config-id}',
            path_variables={'dhcp_relay_config_id': 'dhcp-relay-config-id'},
            query_parameters={}, content_type='application/json')
        get_input_type = type.StructType('operation-input', {
            'dhcp_relay_config_id': type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template=
            '/policy/api/v1/infra/dhcp-relay-configs/{dhcp-relay-config-id}',
            path_variables={'dhcp_relay_config_id': 'dhcp-relay-config-id'},
            query_parameters={}, content_type='application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/dhcp-relay-configs',
            path_variables={}, query_parameters={'cursor': 'cursor',
            'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        patch_input_type = type.StructType('operation-input', {
            'dhcp_relay_config_id': type.StringType(), 'dhcp_relay_config':
            type.ReferenceType('com.vmware.nsx_policy.model_client',
            'DhcpRelayConfig')})
        patch_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        patch_input_value_validator_list = [HasFieldsOfValidator()]
        patch_output_validator_list = []
        patch_rest_metadata = OperationRestMetadata(http_method='PATCH',
            url_template=
            '/policy/api/v1/infra/dhcp-relay-configs/{dhcp-relay-config-id}',
            request_body_parameter='dhcp_relay_config', path_variables={
            'dhcp_relay_config_id': 'dhcp-relay-config-id'},
            query_parameters={}, content_type='application/json')
        update_input_type = type.StructType('operation-input', {
            'dhcp_relay_config_id': type.StringType(), 'dhcp_relay_config':
            type.ReferenceType('com.vmware.nsx_policy.model_client',
            'DhcpRelayConfig')})
        update_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(http_method='PUT',
            url_template=
            '/policy/api/v1/infra/dhcp-relay-configs/{dhcp-relay-config-id}',
            request_body_parameter='dhcp_relay_config', path_variables={
            'dhcp_relay_config_id': 'dhcp-relay-config-id'},
            query_parameters={}, content_type='application/json')
        operations = {'delete': {'input_type': delete_input_type,
            'output_type': type.VoidType(), 'errors': delete_error_dict,
            'input_value_validator_list': delete_input_value_validator_list,
            'output_validator_list': delete_output_validator_list,
            'task_type': TaskType.NONE}, 'get': {'input_type':
            get_input_type, 'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'DhcpRelayConfig'),
            'errors': get_error_dict, 'input_value_validator_list':
            get_input_value_validator_list, 'output_validator_list':
            get_output_validator_list, 'task_type': TaskType.NONE}, 'list':
            {'input_type': list_input_type, 'output_type': type.
            ReferenceType('com.vmware.nsx_policy.model_client',
            'DhcpRelayConfigListResult'), 'errors': list_error_dict,
            'input_value_validator_list': list_input_value_validator_list,
            'output_validator_list': list_output_validator_list,
            'task_type': TaskType.NONE}, 'patch': {'input_type':
            patch_input_type, 'output_type': type.VoidType(), 'errors':
            patch_error_dict, 'input_value_validator_list':
            patch_input_value_validator_list, 'output_validator_list':
            patch_output_validator_list, 'task_type': TaskType.NONE},
            'update': {'input_type': update_input_type, 'output_type': type
            .ReferenceType('com.vmware.nsx_policy.model_client',
            'DhcpRelayConfig'), 'errors': update_error_dict,
            'input_value_validator_list': update_input_value_validator_list,
            'output_validator_list': update_output_validator_list,
            'task_type': TaskType.NONE}}
        rest_metadata = {'delete': delete_rest_metadata, 'get':
            get_rest_metadata, 'list': list_rest_metadata, 'patch':
            patch_rest_metadata, 'update': update_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.dhcp_relay_configs', config=config,
            operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)


class _DhcpServerConfigsStub(ApiInterfaceStub):

    def __init__(self, config):
        delete_input_type = type.StructType('operation-input', {
            'dhcp_server_config_id': type.StringType()})
        delete_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template=
            '/policy/api/v1/infra/dhcp-server-configs/{dhcp-server-config-id}',
            path_variables={'dhcp_server_config_id':
            'dhcp-server-config-id'}, query_parameters={}, content_type=
            'application/json')
        get_input_type = type.StructType('operation-input', {
            'dhcp_server_config_id': type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template=
            '/policy/api/v1/infra/dhcp-server-configs/{dhcp-server-config-id}',
            path_variables={'dhcp_server_config_id':
            'dhcp-server-config-id'}, query_parameters={}, content_type=
            'application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/dhcp-server-configs',
            path_variables={}, query_parameters={'cursor': 'cursor',
            'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        patch_input_type = type.StructType('operation-input', {
            'dhcp_server_config_id': type.StringType(),
            'dhcp_server_config': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'DhcpServerConfig')})
        patch_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        patch_input_value_validator_list = [HasFieldsOfValidator()]
        patch_output_validator_list = []
        patch_rest_metadata = OperationRestMetadata(http_method='PATCH',
            url_template=
            '/policy/api/v1/infra/dhcp-server-configs/{dhcp-server-config-id}',
            request_body_parameter='dhcp_server_config', path_variables={
            'dhcp_server_config_id': 'dhcp-server-config-id'},
            query_parameters={}, content_type='application/json')
        update_input_type = type.StructType('operation-input', {
            'dhcp_server_config_id': type.StringType(),
            'dhcp_server_config': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'DhcpServerConfig')})
        update_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(http_method='PUT',
            url_template=
            '/policy/api/v1/infra/dhcp-server-configs/{dhcp-server-config-id}',
            request_body_parameter='dhcp_server_config', path_variables={
            'dhcp_server_config_id': 'dhcp-server-config-id'},
            query_parameters={}, content_type='application/json')
        operations = {'delete': {'input_type': delete_input_type,
            'output_type': type.VoidType(), 'errors': delete_error_dict,
            'input_value_validator_list': delete_input_value_validator_list,
            'output_validator_list': delete_output_validator_list,
            'task_type': TaskType.NONE}, 'get': {'input_type':
            get_input_type, 'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'DhcpServerConfig'),
            'errors': get_error_dict, 'input_value_validator_list':
            get_input_value_validator_list, 'output_validator_list':
            get_output_validator_list, 'task_type': TaskType.NONE}, 'list':
            {'input_type': list_input_type, 'output_type': type.
            ReferenceType('com.vmware.nsx_policy.model_client',
            'DhcpServerConfigListResult'), 'errors': list_error_dict,
            'input_value_validator_list': list_input_value_validator_list,
            'output_validator_list': list_output_validator_list,
            'task_type': TaskType.NONE}, 'patch': {'input_type':
            patch_input_type, 'output_type': type.VoidType(), 'errors':
            patch_error_dict, 'input_value_validator_list':
            patch_input_value_validator_list, 'output_validator_list':
            patch_output_validator_list, 'task_type': TaskType.NONE},
            'update': {'input_type': update_input_type, 'output_type': type
            .ReferenceType('com.vmware.nsx_policy.model_client',
            'DhcpServerConfig'), 'errors': update_error_dict,
            'input_value_validator_list': update_input_value_validator_list,
            'output_validator_list': update_output_validator_list,
            'task_type': TaskType.NONE}}
        rest_metadata = {'delete': delete_rest_metadata, 'get':
            get_rest_metadata, 'list': list_rest_metadata, 'patch':
            patch_rest_metadata, 'update': update_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.dhcp_server_configs', config=
            config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)


class _DnsForwarderZonesStub(ApiInterfaceStub):

    def __init__(self, config):
        delete_input_type = type.StructType('operation-input', {
            'dns_forwarder_zone_id': type.StringType()})
        delete_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template=
            '/policy/api/v1/infra/dns-forwarder-zones/{dns-forwarder-zone-id}',
            path_variables={'dns_forwarder_zone_id':
            'dns-forwarder-zone-id'}, query_parameters={}, content_type=
            'application/json')
        get_input_type = type.StructType('operation-input', {
            'dns_forwarder_zone_id': type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template=
            '/policy/api/v1/infra/dns-forwarder-zones/{dns-forwarder-zone-id}',
            path_variables={'dns_forwarder_zone_id':
            'dns-forwarder-zone-id'}, query_parameters={}, content_type=
            'application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/dns-forwarder-zones',
            path_variables={}, query_parameters={'cursor': 'cursor',
            'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        patch_input_type = type.StructType('operation-input', {
            'dns_forwarder_zone_id': type.StringType(),
            'policy_dns_forwarder_zone': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'PolicyDnsForwarderZone')})
        patch_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        patch_input_value_validator_list = [HasFieldsOfValidator()]
        patch_output_validator_list = []
        patch_rest_metadata = OperationRestMetadata(http_method='PATCH',
            url_template=
            '/policy/api/v1/infra/dns-forwarder-zones/{dns-forwarder-zone-id}',
            request_body_parameter='policy_dns_forwarder_zone',
            path_variables={'dns_forwarder_zone_id':
            'dns-forwarder-zone-id'}, query_parameters={}, content_type=
            'application/json')
        update_input_type = type.StructType('operation-input', {
            'dns_forwarder_zone_id': type.StringType(),
            'policy_dns_forwarder_zone': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'PolicyDnsForwarderZone')})
        update_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(http_method='PUT',
            url_template=
            '/policy/api/v1/infra/dns-forwarder-zones/{dns-forwarder-zone-id}',
            request_body_parameter='policy_dns_forwarder_zone',
            path_variables={'dns_forwarder_zone_id':
            'dns-forwarder-zone-id'}, query_parameters={}, content_type=
            'application/json')
        operations = {'delete': {'input_type': delete_input_type,
            'output_type': type.VoidType(), 'errors': delete_error_dict,
            'input_value_validator_list': delete_input_value_validator_list,
            'output_validator_list': delete_output_validator_list,
            'task_type': TaskType.NONE}, 'get': {'input_type':
            get_input_type, 'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'PolicyDnsForwarderZone'),
            'errors': get_error_dict, 'input_value_validator_list':
            get_input_value_validator_list, 'output_validator_list':
            get_output_validator_list, 'task_type': TaskType.NONE}, 'list':
            {'input_type': list_input_type, 'output_type': type.
            ReferenceType('com.vmware.nsx_policy.model_client',
            'PolicyDnsForwarderZoneListResult'), 'errors': list_error_dict,
            'input_value_validator_list': list_input_value_validator_list,
            'output_validator_list': list_output_validator_list,
            'task_type': TaskType.NONE}, 'patch': {'input_type':
            patch_input_type, 'output_type': type.VoidType(), 'errors':
            patch_error_dict, 'input_value_validator_list':
            patch_input_value_validator_list, 'output_validator_list':
            patch_output_validator_list, 'task_type': TaskType.NONE},
            'update': {'input_type': update_input_type, 'output_type': type
            .ReferenceType('com.vmware.nsx_policy.model_client',
            'PolicyDnsForwarderZone'), 'errors': update_error_dict,
            'input_value_validator_list': update_input_value_validator_list,
            'output_validator_list': update_output_validator_list,
            'task_type': TaskType.NONE}}
        rest_metadata = {'delete': delete_rest_metadata, 'get':
            get_rest_metadata, 'list': list_rest_metadata, 'patch':
            patch_rest_metadata, 'update': update_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.dns_forwarder_zones', config=
            config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)


class _DomainsStub(ApiInterfaceStub):

    def __init__(self, config):
        get_input_type = type.StructType('operation-input', {'domain_id':
            type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/domains/{domain-id}',
            path_variables={'domain_id': 'domain-id'}, query_parameters={},
            content_type='application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/domains', path_variables={},
            query_parameters={'cursor': 'cursor',
            'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        operations = {'get': {'input_type': get_input_type, 'output_type':
            type.ReferenceType('com.vmware.nsx_policy.model_client',
            'Domain'), 'errors': get_error_dict,
            'input_value_validator_list': get_input_value_validator_list,
            'output_validator_list': get_output_validator_list, 'task_type':
            TaskType.NONE}, 'list': {'input_type': list_input_type,
            'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'DomainListResult'),
            'errors': list_error_dict, 'input_value_validator_list':
            list_input_value_validator_list, 'output_validator_list':
            list_output_validator_list, 'task_type': TaskType.NONE}}
        rest_metadata = {'get': get_rest_metadata, 'list': list_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.domains', config=config,
            operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)


class _DraftsStub(ApiInterfaceStub):

    def __init__(self, config):
        abort_input_type = type.StructType('operation-input', {'draft_id':
            type.StringType()})
        abort_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        abort_input_value_validator_list = []
        abort_output_validator_list = []
        abort_rest_metadata = OperationRestMetadata(http_method='POST',
            url_template=
            '/policy/api/v1/infra/drafts/{draft-id}?action=abort',
            path_variables={'draft_id': 'draft-id'}, query_parameters={},
            content_type='application/json')
        delete_input_type = type.StructType('operation-input', {'draft_id':
            type.StringType()})
        delete_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template='/policy/api/v1/infra/drafts/{draft-id}',
            path_variables={'draft_id': 'draft-id'}, query_parameters={},
            content_type='application/json')
        get_input_type = type.StructType('operation-input', {'draft_id':
            type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/drafts/{draft-id}',
            path_variables={'draft_id': 'draft-id'}, query_parameters={},
            content_type='application/json')
        list_input_type = type.StructType('operation-input', {'auto_drafts':
            type.OptionalType(type.BooleanType()), 'cursor': type.
            OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/drafts', path_variables={},
            query_parameters={'auto_drafts': 'auto_drafts', 'cursor':
            'cursor', 'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        patch_input_type = type.StructType('operation-input', {'draft_id':
            type.StringType(), 'policy_draft': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'PolicyDraft')})
        patch_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        patch_input_value_validator_list = [HasFieldsOfValidator()]
        patch_output_validator_list = []
        patch_rest_metadata = OperationRestMetadata(http_method='PATCH',
            url_template='/policy/api/v1/infra/drafts/{draft-id}',
            request_body_parameter='policy_draft', path_variables={
            'draft_id': 'draft-id'}, query_parameters={}, content_type=
            'application/json')
        publish_input_type = type.StructType('operation-input', {'draft_id':
            type.StringType(), 'infra': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'Infra')})
        publish_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        publish_input_value_validator_list = [HasFieldsOfValidator()]
        publish_output_validator_list = []
        publish_rest_metadata = OperationRestMetadata(http_method='POST',
            url_template=
            '/policy/api/v1/infra/drafts/{draft-id}?action=publish',
            request_body_parameter='infra', path_variables={'draft_id':
            'draft-id'}, query_parameters={}, content_type='application/json')
        update_input_type = type.StructType('operation-input', {'draft_id':
            type.StringType(), 'policy_draft': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'PolicyDraft')})
        update_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(http_method='PUT',
            url_template='/policy/api/v1/infra/drafts/{draft-id}',
            request_body_parameter='policy_draft', path_variables={
            'draft_id': 'draft-id'}, query_parameters={}, content_type=
            'application/json')
        operations = {'abort': {'input_type': abort_input_type,
            'output_type': type.VoidType(), 'errors': abort_error_dict,
            'input_value_validator_list': abort_input_value_validator_list,
            'output_validator_list': abort_output_validator_list,
            'task_type': TaskType.NONE}, 'delete': {'input_type':
            delete_input_type, 'output_type': type.VoidType(), 'errors':
            delete_error_dict, 'input_value_validator_list':
            delete_input_value_validator_list, 'output_validator_list':
            delete_output_validator_list, 'task_type': TaskType.NONE},
            'get': {'input_type': get_input_type, 'output_type': type.
            ReferenceType('com.vmware.nsx_policy.model_client',
            'PolicyDraft'), 'errors': get_error_dict,
            'input_value_validator_list': get_input_value_validator_list,
            'output_validator_list': get_output_validator_list, 'task_type':
            TaskType.NONE}, 'list': {'input_type': list_input_type,
            'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'PolicyDraftListResult'),
            'errors': list_error_dict, 'input_value_validator_list':
            list_input_value_validator_list, 'output_validator_list':
            list_output_validator_list, 'task_type': TaskType.NONE},
            'patch': {'input_type': patch_input_type, 'output_type': type.
            VoidType(), 'errors': patch_error_dict,
            'input_value_validator_list': patch_input_value_validator_list,
            'output_validator_list': patch_output_validator_list,
            'task_type': TaskType.NONE}, 'publish': {'input_type':
            publish_input_type, 'output_type': type.VoidType(), 'errors':
            publish_error_dict, 'input_value_validator_list':
            publish_input_value_validator_list, 'output_validator_list':
            publish_output_validator_list, 'task_type': TaskType.NONE},
            'update': {'input_type': update_input_type, 'output_type': type
            .ReferenceType('com.vmware.nsx_policy.model_client',
            'PolicyDraft'), 'errors': update_error_dict,
            'input_value_validator_list': update_input_value_validator_list,
            'output_validator_list': update_output_validator_list,
            'task_type': TaskType.NONE}}
        rest_metadata = {'abort': abort_rest_metadata, 'delete':
            delete_rest_metadata, 'get': get_rest_metadata, 'list':
            list_rest_metadata, 'patch': patch_rest_metadata, 'publish':
            publish_rest_metadata, 'update': update_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.drafts', config=config, operations
            =operations, rest_metadata=rest_metadata, is_vapi_rest=False)


class _GroupAssociationsStub(ApiInterfaceStub):

    def __init__(self, config):
        list_input_type = type.StructType('operation-input', {'intent_path':
            type.StringType(), 'cursor': type.OptionalType(type.StringType(
            )), 'enforcement_point_path': type.OptionalType(type.StringType
            ()), 'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = []
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/group-associations',
            path_variables={}, query_parameters={'intent_path':
            'intent_path', 'cursor': 'cursor', 'enforcement_point_path':
            'enforcement_point_path', 'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        operations = {'list': {'input_type': list_input_type, 'output_type':
            type.ReferenceType('com.vmware.nsx_policy.model_client',
            'PolicyResourceReferenceForEPListResult'), 'errors':
            list_error_dict, 'input_value_validator_list':
            list_input_value_validator_list, 'output_validator_list':
            list_output_validator_list, 'task_type': TaskType.NONE}}
        rest_metadata = {'list': list_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.group_associations', config=config,
            operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)


class _IpfixCollectorProfilesStub(ApiInterfaceStub):

    def __init__(self, config):
        delete_input_type = type.StructType('operation-input', {
            'ipfix_collector_profile_id': type.StringType()})
        delete_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template=
            '/policy/api/v1/infra/ipfix-collector-profiles/{ipfix-collector-profile-id}'
            , path_variables={'ipfix_collector_profile_id':
            'ipfix-collector-profile-id'}, query_parameters={},
            content_type='application/json')
        get_input_type = type.StructType('operation-input', {
            'ipfix_collector_profile_id': type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template=
            '/policy/api/v1/infra/ipfix-collector-profiles/{ipfix-collector-profile-id}'
            , path_variables={'ipfix_collector_profile_id':
            'ipfix-collector-profile-id'}, query_parameters={},
            content_type='application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/ipfix-collector-profiles',
            path_variables={}, query_parameters={'cursor': 'cursor',
            'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        patch_input_type = type.StructType('operation-input', {
            'ipfix_collector_profile_id': type.StringType(),
            'i_PFIX_collector_profile': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'IPFIXCollectorProfile')})
        patch_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        patch_input_value_validator_list = [HasFieldsOfValidator()]
        patch_output_validator_list = []
        patch_rest_metadata = OperationRestMetadata(http_method='PATCH',
            url_template=
            '/policy/api/v1/infra/ipfix-collector-profiles/{ipfix-collector-profile-id}'
            , request_body_parameter='i_PFIX_collector_profile',
            path_variables={'ipfix_collector_profile_id':
            'ipfix-collector-profile-id'}, query_parameters={},
            content_type='application/json')
        update_input_type = type.StructType('operation-input', {
            'ipfix_collector_profile_id': type.StringType(),
            'i_PFIX_collector_profile': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'IPFIXCollectorProfile')})
        update_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(http_method='PUT',
            url_template=
            '/policy/api/v1/infra/ipfix-collector-profiles/{ipfix-collector-profile-id}'
            , request_body_parameter='i_PFIX_collector_profile',
            path_variables={'ipfix_collector_profile_id':
            'ipfix-collector-profile-id'}, query_parameters={},
            content_type='application/json')
        operations = {'delete': {'input_type': delete_input_type,
            'output_type': type.VoidType(), 'errors': delete_error_dict,
            'input_value_validator_list': delete_input_value_validator_list,
            'output_validator_list': delete_output_validator_list,
            'task_type': TaskType.NONE}, 'get': {'input_type':
            get_input_type, 'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'IPFIXCollectorProfile'),
            'errors': get_error_dict, 'input_value_validator_list':
            get_input_value_validator_list, 'output_validator_list':
            get_output_validator_list, 'task_type': TaskType.NONE}, 'list':
            {'input_type': list_input_type, 'output_type': type.
            ReferenceType('com.vmware.nsx_policy.model_client',
            'IPFIXCollectorProfileListResult'), 'errors': list_error_dict,
            'input_value_validator_list': list_input_value_validator_list,
            'output_validator_list': list_output_validator_list,
            'task_type': TaskType.NONE}, 'patch': {'input_type':
            patch_input_type, 'output_type': type.VoidType(), 'errors':
            patch_error_dict, 'input_value_validator_list':
            patch_input_value_validator_list, 'output_validator_list':
            patch_output_validator_list, 'task_type': TaskType.NONE},
            'update': {'input_type': update_input_type, 'output_type': type
            .ReferenceType('com.vmware.nsx_policy.model_client',
            'IPFIXCollectorProfile'), 'errors': update_error_dict,
            'input_value_validator_list': update_input_value_validator_list,
            'output_validator_list': update_output_validator_list,
            'task_type': TaskType.NONE}}
        rest_metadata = {'delete': delete_rest_metadata, 'get':
            get_rest_metadata, 'list': list_rest_metadata, 'patch':
            patch_rest_metadata, 'update': update_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.ipfix_collector_profiles', config=
            config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)


class _IpfixDfwCollectorProfilesStub(ApiInterfaceStub):

    def __init__(self, config):
        delete_input_type = type.StructType('operation-input', {
            'ipfix_dfw_collector_profile_id': type.StringType()})
        delete_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template=
            '/policy/api/v1/infra/ipfix-dfw-collector-profiles/{ipfix-dfw-collector-profile-id}'
            , path_variables={'ipfix_dfw_collector_profile_id':
            'ipfix-dfw-collector-profile-id'}, query_parameters={},
            content_type='application/json')
        get_input_type = type.StructType('operation-input', {
            'ipfix_dfw_collector_profile_id': type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template=
            '/policy/api/v1/infra/ipfix-dfw-collector-profiles/{ipfix-dfw-collector-profile-id}'
            , path_variables={'ipfix_dfw_collector_profile_id':
            'ipfix-dfw-collector-profile-id'}, query_parameters={},
            content_type='application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template=
            '/policy/api/v1/infra/ipfix-dfw-collector-profiles',
            path_variables={}, query_parameters={'cursor': 'cursor',
            'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        patch_input_type = type.StructType('operation-input', {
            'ipfix_dfw_collector_profile_id': type.StringType(),
            'i_PFIXDFW_collector_profile': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'IPFIXDFWCollectorProfile')})
        patch_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        patch_input_value_validator_list = [HasFieldsOfValidator()]
        patch_output_validator_list = []
        patch_rest_metadata = OperationRestMetadata(http_method='PATCH',
            url_template=
            '/policy/api/v1/infra/ipfix-dfw-collector-profiles/{ipfix-dfw-collector-profile-id}'
            , request_body_parameter='i_PFIXDFW_collector_profile',
            path_variables={'ipfix_dfw_collector_profile_id':
            'ipfix-dfw-collector-profile-id'}, query_parameters={},
            content_type='application/json')
        update_input_type = type.StructType('operation-input', {
            'ipfix_dfw_collector_profile_id': type.StringType(),
            'i_PFIXDFW_collector_profile': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'IPFIXDFWCollectorProfile')})
        update_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(http_method='PUT',
            url_template=
            '/policy/api/v1/infra/ipfix-dfw-collector-profiles/{ipfix-dfw-collector-profile-id}'
            , request_body_parameter='i_PFIXDFW_collector_profile',
            path_variables={'ipfix_dfw_collector_profile_id':
            'ipfix-dfw-collector-profile-id'}, query_parameters={},
            content_type='application/json')
        operations = {'delete': {'input_type': delete_input_type,
            'output_type': type.VoidType(), 'errors': delete_error_dict,
            'input_value_validator_list': delete_input_value_validator_list,
            'output_validator_list': delete_output_validator_list,
            'task_type': TaskType.NONE}, 'get': {'input_type':
            get_input_type, 'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client',
            'IPFIXDFWCollectorProfile'), 'errors': get_error_dict,
            'input_value_validator_list': get_input_value_validator_list,
            'output_validator_list': get_output_validator_list, 'task_type':
            TaskType.NONE}, 'list': {'input_type': list_input_type,
            'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client',
            'IPFIXDFWCollectorProfileListResult'), 'errors':
            list_error_dict, 'input_value_validator_list':
            list_input_value_validator_list, 'output_validator_list':
            list_output_validator_list, 'task_type': TaskType.NONE},
            'patch': {'input_type': patch_input_type, 'output_type': type.
            VoidType(), 'errors': patch_error_dict,
            'input_value_validator_list': patch_input_value_validator_list,
            'output_validator_list': patch_output_validator_list,
            'task_type': TaskType.NONE}, 'update': {'input_type':
            update_input_type, 'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client',
            'IPFIXDFWCollectorProfile'), 'errors': update_error_dict,
            'input_value_validator_list': update_input_value_validator_list,
            'output_validator_list': update_output_validator_list,
            'task_type': TaskType.NONE}}
        rest_metadata = {'delete': delete_rest_metadata, 'get':
            get_rest_metadata, 'list': list_rest_metadata, 'patch':
            patch_rest_metadata, 'update': update_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.ipfix_dfw_collector_profiles',
            config=config, operations=operations, rest_metadata=
            rest_metadata, is_vapi_rest=False)


class _IpfixDfwProfilesStub(ApiInterfaceStub):

    def __init__(self, config):
        delete_input_type = type.StructType('operation-input', {
            'ipfix_dfw_profile_id': type.StringType()})
        delete_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template=
            '/policy/api/v1/infra/ipfix-dfw-profiles/{ipfix-dfw-profile-id}',
            path_variables={'ipfix_dfw_profile_id': 'ipfix-dfw-profile-id'},
            query_parameters={}, content_type='application/json')
        get_input_type = type.StructType('operation-input', {
            'ipfix_dfw_profile_id': type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template=
            '/policy/api/v1/infra/ipfix-dfw-profiles/{ipfix-dfw-profile-id}',
            path_variables={'ipfix_dfw_profile_id': 'ipfix-dfw-profile-id'},
            query_parameters={}, content_type='application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/ipfix-dfw-profiles',
            path_variables={}, query_parameters={'cursor': 'cursor',
            'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        patch_input_type = type.StructType('operation-input', {
            'ipfix_dfw_profile_id': type.StringType(), 'i_PFIXDFW_profile':
            type.ReferenceType('com.vmware.nsx_policy.model_client',
            'IPFIXDFWProfile')})
        patch_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        patch_input_value_validator_list = [HasFieldsOfValidator()]
        patch_output_validator_list = []
        patch_rest_metadata = OperationRestMetadata(http_method='PATCH',
            url_template=
            '/policy/api/v1/infra/ipfix-dfw-profiles/{ipfix-dfw-profile-id}',
            request_body_parameter='i_PFIXDFW_profile', path_variables={
            'ipfix_dfw_profile_id': 'ipfix-dfw-profile-id'},
            query_parameters={}, content_type='application/json')
        update_input_type = type.StructType('operation-input', {
            'ipfix_dfw_profile_id': type.StringType(), 'i_PFIXDFW_profile':
            type.ReferenceType('com.vmware.nsx_policy.model_client',
            'IPFIXDFWProfile')})
        update_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(http_method='PUT',
            url_template=
            '/policy/api/v1/infra/ipfix-dfw-profiles/{ipfix-dfw-profile-id}',
            request_body_parameter='i_PFIXDFW_profile', path_variables={
            'ipfix_dfw_profile_id': 'ipfix-dfw-profile-id'},
            query_parameters={}, content_type='application/json')
        operations = {'delete': {'input_type': delete_input_type,
            'output_type': type.VoidType(), 'errors': delete_error_dict,
            'input_value_validator_list': delete_input_value_validator_list,
            'output_validator_list': delete_output_validator_list,
            'task_type': TaskType.NONE}, 'get': {'input_type':
            get_input_type, 'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'IPFIXDFWProfile'),
            'errors': get_error_dict, 'input_value_validator_list':
            get_input_value_validator_list, 'output_validator_list':
            get_output_validator_list, 'task_type': TaskType.NONE}, 'list':
            {'input_type': list_input_type, 'output_type': type.
            ReferenceType('com.vmware.nsx_policy.model_client',
            'IPFIXDFWProfileListResult'), 'errors': list_error_dict,
            'input_value_validator_list': list_input_value_validator_list,
            'output_validator_list': list_output_validator_list,
            'task_type': TaskType.NONE}, 'patch': {'input_type':
            patch_input_type, 'output_type': type.VoidType(), 'errors':
            patch_error_dict, 'input_value_validator_list':
            patch_input_value_validator_list, 'output_validator_list':
            patch_output_validator_list, 'task_type': TaskType.NONE},
            'update': {'input_type': update_input_type, 'output_type': type
            .ReferenceType('com.vmware.nsx_policy.model_client',
            'IPFIXDFWProfile'), 'errors': update_error_dict,
            'input_value_validator_list': update_input_value_validator_list,
            'output_validator_list': update_output_validator_list,
            'task_type': TaskType.NONE}}
        rest_metadata = {'delete': delete_rest_metadata, 'get':
            get_rest_metadata, 'list': list_rest_metadata, 'patch':
            patch_rest_metadata, 'update': update_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.ipfix_dfw_profiles', config=config,
            operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)


class _IpfixL2CollectorProfilesStub(ApiInterfaceStub):

    def __init__(self, config):
        delete_input_type = type.StructType('operation-input', {
            'ipfix_l2_collector_profile_id': type.StringType()})
        delete_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template=
            '/policy/api/v1/infra/ipfix-l2-collector-profiles/{ipfix-l2-collector-profile-id}'
            , path_variables={'ipfix_l2_collector_profile_id':
            'ipfix-l2-collector-profile-id'}, query_parameters={},
            content_type='application/json')
        get_input_type = type.StructType('operation-input', {
            'ipfix_l2_collector_profile_id': type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template=
            '/policy/api/v1/infra/ipfix-l2-collector-profiles/{ipfix-l2-collector-profile-id}'
            , path_variables={'ipfix_l2_collector_profile_id':
            'ipfix-l2-collector-profile-id'}, query_parameters={},
            content_type='application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/ipfix-l2-collector-profiles',
            path_variables={}, query_parameters={'cursor': 'cursor',
            'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        patch_input_type = type.StructType('operation-input', {
            'ipfix_l2_collector_profile_id': type.StringType(),
            'i_PFIX_l2_collector_profile': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'IPFIXL2CollectorProfile')})
        patch_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        patch_input_value_validator_list = [HasFieldsOfValidator()]
        patch_output_validator_list = []
        patch_rest_metadata = OperationRestMetadata(http_method='PATCH',
            url_template=
            '/policy/api/v1/infra/ipfix-l2-collector-profiles/{ipfix-l2-collector-profile-id}'
            , request_body_parameter='i_PFIX_l2_collector_profile',
            path_variables={'ipfix_l2_collector_profile_id':
            'ipfix-l2-collector-profile-id'}, query_parameters={},
            content_type='application/json')
        update_input_type = type.StructType('operation-input', {
            'ipfix_l2_collector_profile_id': type.StringType(),
            'i_PFIX_l2_collector_profile': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'IPFIXL2CollectorProfile')})
        update_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(http_method='PUT',
            url_template=
            '/policy/api/v1/infra/ipfix-l2-collector-profiles/{ipfix-l2-collector-profile-id}'
            , request_body_parameter='i_PFIX_l2_collector_profile',
            path_variables={'ipfix_l2_collector_profile_id':
            'ipfix-l2-collector-profile-id'}, query_parameters={},
            content_type='application/json')
        operations = {'delete': {'input_type': delete_input_type,
            'output_type': type.VoidType(), 'errors': delete_error_dict,
            'input_value_validator_list': delete_input_value_validator_list,
            'output_validator_list': delete_output_validator_list,
            'task_type': TaskType.NONE}, 'get': {'input_type':
            get_input_type, 'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'IPFIXL2CollectorProfile'
            ), 'errors': get_error_dict, 'input_value_validator_list':
            get_input_value_validator_list, 'output_validator_list':
            get_output_validator_list, 'task_type': TaskType.NONE}, 'list':
            {'input_type': list_input_type, 'output_type': type.
            ReferenceType('com.vmware.nsx_policy.model_client',
            'IPFIXL2CollectorProfileListResult'), 'errors': list_error_dict,
            'input_value_validator_list': list_input_value_validator_list,
            'output_validator_list': list_output_validator_list,
            'task_type': TaskType.NONE}, 'patch': {'input_type':
            patch_input_type, 'output_type': type.VoidType(), 'errors':
            patch_error_dict, 'input_value_validator_list':
            patch_input_value_validator_list, 'output_validator_list':
            patch_output_validator_list, 'task_type': TaskType.NONE},
            'update': {'input_type': update_input_type, 'output_type': type
            .ReferenceType('com.vmware.nsx_policy.model_client',
            'IPFIXL2CollectorProfile'), 'errors': update_error_dict,
            'input_value_validator_list': update_input_value_validator_list,
            'output_validator_list': update_output_validator_list,
            'task_type': TaskType.NONE}}
        rest_metadata = {'delete': delete_rest_metadata, 'get':
            get_rest_metadata, 'list': list_rest_metadata, 'patch':
            patch_rest_metadata, 'update': update_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.ipfix_l2_collector_profiles',
            config=config, operations=operations, rest_metadata=
            rest_metadata, is_vapi_rest=False)


class _IpfixL2ProfilesStub(ApiInterfaceStub):

    def __init__(self, config):
        delete_input_type = type.StructType('operation-input', {
            'ipfix_l2_profile_id': type.StringType()})
        delete_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template=
            '/policy/api/v1/infra/ipfix-l2-profiles/{ipfix-l2-profile-id}',
            path_variables={'ipfix_l2_profile_id': 'ipfix-l2-profile-id'},
            query_parameters={}, content_type='application/json')
        get_input_type = type.StructType('operation-input', {
            'ipfix_l2_profile_id': type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template=
            '/policy/api/v1/infra/ipfix-l2-profiles/{ipfix-l2-profile-id}',
            path_variables={'ipfix_l2_profile_id': 'ipfix-l2-profile-id'},
            query_parameters={}, content_type='application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/ipfix-l2-profiles',
            path_variables={}, query_parameters={'cursor': 'cursor',
            'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        patch_input_type = type.StructType('operation-input', {
            'ipfix_l2_profile_id': type.StringType(), 'i_PFIX_l2_profile':
            type.ReferenceType('com.vmware.nsx_policy.model_client',
            'IPFIXL2Profile')})
        patch_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        patch_input_value_validator_list = [HasFieldsOfValidator()]
        patch_output_validator_list = []
        patch_rest_metadata = OperationRestMetadata(http_method='PATCH',
            url_template=
            '/policy/api/v1/infra/ipfix-l2-profiles/{ipfix-l2-profile-id}',
            request_body_parameter='i_PFIX_l2_profile', path_variables={
            'ipfix_l2_profile_id': 'ipfix-l2-profile-id'}, query_parameters
            ={}, content_type='application/json')
        update_input_type = type.StructType('operation-input', {
            'ipfix_l2_profile_id': type.StringType(), 'i_PFIX_l2_profile':
            type.ReferenceType('com.vmware.nsx_policy.model_client',
            'IPFIXL2Profile')})
        update_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(http_method='PUT',
            url_template=
            '/policy/api/v1/infra/ipfix-l2-profiles/{ipfix-l2-profile-id}',
            request_body_parameter='i_PFIX_l2_profile', path_variables={
            'ipfix_l2_profile_id': 'ipfix-l2-profile-id'}, query_parameters
            ={}, content_type='application/json')
        operations = {'delete': {'input_type': delete_input_type,
            'output_type': type.VoidType(), 'errors': delete_error_dict,
            'input_value_validator_list': delete_input_value_validator_list,
            'output_validator_list': delete_output_validator_list,
            'task_type': TaskType.NONE}, 'get': {'input_type':
            get_input_type, 'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'IPFIXL2Profile'),
            'errors': get_error_dict, 'input_value_validator_list':
            get_input_value_validator_list, 'output_validator_list':
            get_output_validator_list, 'task_type': TaskType.NONE}, 'list':
            {'input_type': list_input_type, 'output_type': type.
            ReferenceType('com.vmware.nsx_policy.model_client',
            'IPFIXL2ProfileListResult'), 'errors': list_error_dict,
            'input_value_validator_list': list_input_value_validator_list,
            'output_validator_list': list_output_validator_list,
            'task_type': TaskType.NONE}, 'patch': {'input_type':
            patch_input_type, 'output_type': type.VoidType(), 'errors':
            patch_error_dict, 'input_value_validator_list':
            patch_input_value_validator_list, 'output_validator_list':
            patch_output_validator_list, 'task_type': TaskType.NONE},
            'update': {'input_type': update_input_type, 'output_type': type
            .ReferenceType('com.vmware.nsx_policy.model_client',
            'IPFIXL2Profile'), 'errors': update_error_dict,
            'input_value_validator_list': update_input_value_validator_list,
            'output_validator_list': update_output_validator_list,
            'task_type': TaskType.NONE}}
        rest_metadata = {'delete': delete_rest_metadata, 'get':
            get_rest_metadata, 'list': list_rest_metadata, 'patch':
            patch_rest_metadata, 'update': update_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.ipfix_l2_profiles', config=config,
            operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)


class _IpsecVpnDpdProfilesStub(ApiInterfaceStub):

    def __init__(self, config):
        delete_input_type = type.StructType('operation-input', {
            'dpd_profile_id': type.StringType()})
        delete_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template=
            '/policy/api/v1/infra/ipsec-vpn-dpd-profiles/{dpd-profile-id}',
            path_variables={'dpd_profile_id': 'dpd-profile-id'},
            query_parameters={}, content_type='application/json')
        get_input_type = type.StructType('operation-input', {
            'dpd_profile_id': type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template=
            '/policy/api/v1/infra/ipsec-vpn-dpd-profiles/{dpd-profile-id}',
            path_variables={'dpd_profile_id': 'dpd-profile-id'},
            query_parameters={}, content_type='application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/ipsec-vpn-dpd-profiles',
            path_variables={}, query_parameters={'cursor': 'cursor',
            'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        patch_input_type = type.StructType('operation-input', {
            'dpd_profile_id': type.StringType(), 'ip_sec_vpn_dpd_profile':
            type.ReferenceType('com.vmware.nsx_policy.model_client',
            'IPSecVpnDpdProfile')})
        patch_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        patch_input_value_validator_list = [HasFieldsOfValidator()]
        patch_output_validator_list = []
        patch_rest_metadata = OperationRestMetadata(http_method='PATCH',
            url_template=
            '/policy/api/v1/infra/ipsec-vpn-dpd-profiles/{dpd-profile-id}',
            request_body_parameter='ip_sec_vpn_dpd_profile', path_variables
            ={'dpd_profile_id': 'dpd-profile-id'}, query_parameters={},
            content_type='application/json')
        update_input_type = type.StructType('operation-input', {
            'dpd_profile_id': type.StringType(), 'ip_sec_vpn_dpd_profile':
            type.ReferenceType('com.vmware.nsx_policy.model_client',
            'IPSecVpnDpdProfile')})
        update_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(http_method='PUT',
            url_template=
            '/policy/api/v1/infra/ipsec-vpn-dpd-profiles/{dpd-profile-id}',
            request_body_parameter='ip_sec_vpn_dpd_profile', path_variables
            ={'dpd_profile_id': 'dpd-profile-id'}, query_parameters={},
            content_type='application/json')
        operations = {'delete': {'input_type': delete_input_type,
            'output_type': type.VoidType(), 'errors': delete_error_dict,
            'input_value_validator_list': delete_input_value_validator_list,
            'output_validator_list': delete_output_validator_list,
            'task_type': TaskType.NONE}, 'get': {'input_type':
            get_input_type, 'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'IPSecVpnDpdProfile'),
            'errors': get_error_dict, 'input_value_validator_list':
            get_input_value_validator_list, 'output_validator_list':
            get_output_validator_list, 'task_type': TaskType.NONE}, 'list':
            {'input_type': list_input_type, 'output_type': type.
            ReferenceType('com.vmware.nsx_policy.model_client',
            'IPSecVpnDpdProfileListResult'), 'errors': list_error_dict,
            'input_value_validator_list': list_input_value_validator_list,
            'output_validator_list': list_output_validator_list,
            'task_type': TaskType.NONE}, 'patch': {'input_type':
            patch_input_type, 'output_type': type.VoidType(), 'errors':
            patch_error_dict, 'input_value_validator_list':
            patch_input_value_validator_list, 'output_validator_list':
            patch_output_validator_list, 'task_type': TaskType.NONE},
            'update': {'input_type': update_input_type, 'output_type': type
            .ReferenceType('com.vmware.nsx_policy.model_client',
            'IPSecVpnDpdProfile'), 'errors': update_error_dict,
            'input_value_validator_list': update_input_value_validator_list,
            'output_validator_list': update_output_validator_list,
            'task_type': TaskType.NONE}}
        rest_metadata = {'delete': delete_rest_metadata, 'get':
            get_rest_metadata, 'list': list_rest_metadata, 'patch':
            patch_rest_metadata, 'update': update_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.ipsec_vpn_dpd_profiles', config=
            config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)


class _IpsecVpnIkeProfilesStub(ApiInterfaceStub):

    def __init__(self, config):
        delete_input_type = type.StructType('operation-input', {
            'ike_profile_id': type.StringType()})
        delete_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template=
            '/policy/api/v1/infra/ipsec-vpn-ike-profiles/{ike-profile-id}',
            path_variables={'ike_profile_id': 'ike-profile-id'},
            query_parameters={}, content_type='application/json')
        get_input_type = type.StructType('operation-input', {
            'ike_profile_id': type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template=
            '/policy/api/v1/infra/ipsec-vpn-ike-profiles/{ike-profile-id}',
            path_variables={'ike_profile_id': 'ike-profile-id'},
            query_parameters={}, content_type='application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/ipsec-vpn-ike-profiles',
            path_variables={}, query_parameters={'cursor': 'cursor',
            'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        patch_input_type = type.StructType('operation-input', {
            'ike_profile_id': type.StringType(), 'ip_sec_vpn_ike_profile':
            type.ReferenceType('com.vmware.nsx_policy.model_client',
            'IPSecVpnIkeProfile')})
        patch_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        patch_input_value_validator_list = [HasFieldsOfValidator()]
        patch_output_validator_list = []
        patch_rest_metadata = OperationRestMetadata(http_method='PATCH',
            url_template=
            '/policy/api/v1/infra/ipsec-vpn-ike-profiles/{ike-profile-id}',
            request_body_parameter='ip_sec_vpn_ike_profile', path_variables
            ={'ike_profile_id': 'ike-profile-id'}, query_parameters={},
            content_type='application/json')
        update_input_type = type.StructType('operation-input', {
            'ike_profile_id': type.StringType(), 'ip_sec_vpn_ike_profile':
            type.ReferenceType('com.vmware.nsx_policy.model_client',
            'IPSecVpnIkeProfile')})
        update_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(http_method='PUT',
            url_template=
            '/policy/api/v1/infra/ipsec-vpn-ike-profiles/{ike-profile-id}',
            request_body_parameter='ip_sec_vpn_ike_profile', path_variables
            ={'ike_profile_id': 'ike-profile-id'}, query_parameters={},
            content_type='application/json')
        operations = {'delete': {'input_type': delete_input_type,
            'output_type': type.VoidType(), 'errors': delete_error_dict,
            'input_value_validator_list': delete_input_value_validator_list,
            'output_validator_list': delete_output_validator_list,
            'task_type': TaskType.NONE}, 'get': {'input_type':
            get_input_type, 'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'IPSecVpnIkeProfile'),
            'errors': get_error_dict, 'input_value_validator_list':
            get_input_value_validator_list, 'output_validator_list':
            get_output_validator_list, 'task_type': TaskType.NONE}, 'list':
            {'input_type': list_input_type, 'output_type': type.
            ReferenceType('com.vmware.nsx_policy.model_client',
            'IPSecVpnIkeProfileListResult'), 'errors': list_error_dict,
            'input_value_validator_list': list_input_value_validator_list,
            'output_validator_list': list_output_validator_list,
            'task_type': TaskType.NONE}, 'patch': {'input_type':
            patch_input_type, 'output_type': type.VoidType(), 'errors':
            patch_error_dict, 'input_value_validator_list':
            patch_input_value_validator_list, 'output_validator_list':
            patch_output_validator_list, 'task_type': TaskType.NONE},
            'update': {'input_type': update_input_type, 'output_type': type
            .ReferenceType('com.vmware.nsx_policy.model_client',
            'IPSecVpnIkeProfile'), 'errors': update_error_dict,
            'input_value_validator_list': update_input_value_validator_list,
            'output_validator_list': update_output_validator_list,
            'task_type': TaskType.NONE}}
        rest_metadata = {'delete': delete_rest_metadata, 'get':
            get_rest_metadata, 'list': list_rest_metadata, 'patch':
            patch_rest_metadata, 'update': update_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.ipsec_vpn_ike_profiles', config=
            config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)


class _IpsecVpnTunnelProfilesStub(ApiInterfaceStub):

    def __init__(self, config):
        delete_input_type = type.StructType('operation-input', {
            'tunnel_profile_id': type.StringType()})
        delete_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template=
            '/policy/api/v1/infra/ipsec-vpn-tunnel-profiles/{tunnel-profile-id}'
            , path_variables={'tunnel_profile_id': 'tunnel-profile-id'},
            query_parameters={}, content_type='application/json')
        get_input_type = type.StructType('operation-input', {
            'tunnel_profile_id': type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template=
            '/policy/api/v1/infra/ipsec-vpn-tunnel-profiles/{tunnel-profile-id}'
            , path_variables={'tunnel_profile_id': 'tunnel-profile-id'},
            query_parameters={}, content_type='application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/ipsec-vpn-tunnel-profiles',
            path_variables={}, query_parameters={'cursor': 'cursor',
            'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        patch_input_type = type.StructType('operation-input', {
            'tunnel_profile_id': type.StringType(),
            'ip_sec_vpn_tunnel_profile': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'IPSecVpnTunnelProfile')})
        patch_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        patch_input_value_validator_list = [HasFieldsOfValidator()]
        patch_output_validator_list = []
        patch_rest_metadata = OperationRestMetadata(http_method='PATCH',
            url_template=
            '/policy/api/v1/infra/ipsec-vpn-tunnel-profiles/{tunnel-profile-id}'
            , request_body_parameter='ip_sec_vpn_tunnel_profile',
            path_variables={'tunnel_profile_id': 'tunnel-profile-id'},
            query_parameters={}, content_type='application/json')
        update_input_type = type.StructType('operation-input', {
            'tunnel_profile_id': type.StringType(),
            'ip_sec_vpn_tunnel_profile': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'IPSecVpnTunnelProfile')})
        update_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(http_method='PUT',
            url_template=
            '/policy/api/v1/infra/ipsec-vpn-tunnel-profiles/{tunnel-profile-id}'
            , request_body_parameter='ip_sec_vpn_tunnel_profile',
            path_variables={'tunnel_profile_id': 'tunnel-profile-id'},
            query_parameters={}, content_type='application/json')
        operations = {'delete': {'input_type': delete_input_type,
            'output_type': type.VoidType(), 'errors': delete_error_dict,
            'input_value_validator_list': delete_input_value_validator_list,
            'output_validator_list': delete_output_validator_list,
            'task_type': TaskType.NONE}, 'get': {'input_type':
            get_input_type, 'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'IPSecVpnTunnelProfile'),
            'errors': get_error_dict, 'input_value_validator_list':
            get_input_value_validator_list, 'output_validator_list':
            get_output_validator_list, 'task_type': TaskType.NONE}, 'list':
            {'input_type': list_input_type, 'output_type': type.
            ReferenceType('com.vmware.nsx_policy.model_client',
            'IPSecVpnTunnelProfileListResult'), 'errors': list_error_dict,
            'input_value_validator_list': list_input_value_validator_list,
            'output_validator_list': list_output_validator_list,
            'task_type': TaskType.NONE}, 'patch': {'input_type':
            patch_input_type, 'output_type': type.VoidType(), 'errors':
            patch_error_dict, 'input_value_validator_list':
            patch_input_value_validator_list, 'output_validator_list':
            patch_output_validator_list, 'task_type': TaskType.NONE},
            'update': {'input_type': update_input_type, 'output_type': type
            .ReferenceType('com.vmware.nsx_policy.model_client',
            'IPSecVpnTunnelProfile'), 'errors': update_error_dict,
            'input_value_validator_list': update_input_value_validator_list,
            'output_validator_list': update_output_validator_list,
            'task_type': TaskType.NONE}}
        rest_metadata = {'delete': delete_rest_metadata, 'get':
            get_rest_metadata, 'list': list_rest_metadata, 'patch':
            patch_rest_metadata, 'update': update_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.ipsec_vpn_tunnel_profiles', config
            =config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)


class _PartnerServicesStub(ApiInterfaceStub):

    def __init__(self, config):
        get_input_type = type.StructType('operation-input', {'service_name':
            type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = []
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template=
            '/policy/api/v1/infra/partner-services/{service-name}',
            path_variables={'service_name': 'service-name'},
            query_parameters={}, content_type='application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = []
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/partner-services',
            path_variables={}, query_parameters={'cursor': 'cursor',
            'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        operations = {'get': {'input_type': get_input_type, 'output_type':
            type.ReferenceType('com.vmware.nsx_policy.model_client',
            'ServiceDefinition'), 'errors': get_error_dict,
            'input_value_validator_list': get_input_value_validator_list,
            'output_validator_list': get_output_validator_list, 'task_type':
            TaskType.NONE}, 'list': {'input_type': list_input_type,
            'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client',
            'ServiceInsertionServiceListResult'), 'errors': list_error_dict,
            'input_value_validator_list': list_input_value_validator_list,
            'output_validator_list': list_output_validator_list,
            'task_type': TaskType.NONE}}
        rest_metadata = {'get': get_rest_metadata, 'list': list_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.partner_services', config=config,
            operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)


class _PortMirroringProfilesStub(ApiInterfaceStub):

    def __init__(self, config):
        delete_input_type = type.StructType('operation-input', {
            'port_mirroring_profile_id': type.StringType()})
        delete_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template=
            '/policy/api/v1/infra/port-mirroring-profiles/{port-mirroring-profile-id}'
            , path_variables={'port_mirroring_profile_id':
            'port-mirroring-profile-id'}, query_parameters={}, content_type
            ='application/json')
        get_input_type = type.StructType('operation-input', {
            'port_mirroring_profile_id': type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template=
            '/policy/api/v1/infra/port-mirroring-profiles/{port-mirroring-profile-id}'
            , path_variables={'port_mirroring_profile_id':
            'port-mirroring-profile-id'}, query_parameters={}, content_type
            ='application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()), 'included_fields': type.
            OptionalType(type.StringType()), 'page_size': type.OptionalType
            (type.IntegerType()), 'sort_ascending': type.OptionalType(type.
            BooleanType()), 'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/port-mirroring-profiles',
            path_variables={}, query_parameters={'cursor': 'cursor',
            'included_fields': 'included_fields', 'page_size': 'page_size',
            'sort_ascending': 'sort_ascending', 'sort_by': 'sort_by'},
            content_type='application/json')
        patch_input_type = type.StructType('operation-input', {
            'port_mirroring_profile_id': type.StringType(),
            'port_mirroring_profile': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'PortMirroringProfile')})
        patch_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        patch_input_value_validator_list = [HasFieldsOfValidator()]
        patch_output_validator_list = []
        patch_rest_metadata = OperationRestMetadata(http_method='PATCH',
            url_template=
            '/policy/api/v1/infra/port-mirroring-profiles/{port-mirroring-profile-id}'
            , request_body_parameter='port_mirroring_profile',
            path_variables={'port_mirroring_profile_id':
            'port-mirroring-profile-id'}, query_parameters={}, content_type
            ='application/json')
        update_input_type = type.StructType('operation-input', {
            'port_mirroring_profile_id': type.StringType(),
            'port_mirroring_profile': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'PortMirroringProfile')})
        update_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(http_method='PUT',
            url_template=
            '/policy/api/v1/infra/port-mirroring-profiles/{port-mirroring-profile-id}'
            , request_body_parameter='port_mirroring_profile',
            path_variables={'port_mirroring_profile_id':
            'port-mirroring-profile-id'}, query_parameters={}, content_type
            ='application/json')
        operations = {'delete': {'input_type': delete_input_type,
            'output_type': type.VoidType(), 'errors': delete_error_dict,
            'input_value_validator_list': delete_input_value_validator_list,
            'output_validator_list': delete_output_validator_list,
            'task_type': TaskType.NONE}, 'get': {'input_type':
            get_input_type, 'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'PortMirroringProfile'),
            'errors': get_error_dict, 'input_value_validator_list':
            get_input_value_validator_list, 'output_validator_list':
            get_output_validator_list, 'task_type': TaskType.NONE}, 'list':
            {'input_type': list_input_type, 'output_type': type.
            ReferenceType('com.vmware.nsx_policy.model_client',
            'PortMirroringProfileListResult'), 'errors': list_error_dict,
            'input_value_validator_list': list_input_value_validator_list,
            'output_validator_list': list_output_validator_list,
            'task_type': TaskType.NONE}, 'patch': {'input_type':
            patch_input_type, 'output_type': type.VoidType(), 'errors':
            patch_error_dict, 'input_value_validator_list':
            patch_input_value_validator_list, 'output_validator_list':
            patch_output_validator_list, 'task_type': TaskType.NONE},
            'update': {'input_type': update_input_type, 'output_type': type
            .ReferenceType('com.vmware.nsx_policy.model_client',
            'PortMirroringProfile'), 'errors': update_error_dict,
            'input_value_validator_list': update_input_value_validator_list,
            'output_validator_list': update_output_validator_list,
            'task_type': TaskType.NONE}}
        rest_metadata = {'delete': delete_rest_metadata, 'get':
            get_rest_metadata, 'list': list_rest_metadata, 'patch':
            patch_rest_metadata, 'update': update_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.port_mirroring_profiles', config=
            config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)


class _SegmentsStub(ApiInterfaceStub):

    def __init__(self, config):
        delete_input_type = type.StructType('operation-input', {
            'segment_id': type.StringType()})
        delete_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template='/policy/api/v1/infra/segments/{segment-id}',
            path_variables={'segment_id': 'segment-id'}, query_parameters={
            }, content_type='application/json')
        delete_0_input_type = type.StructType('operation-input', {
            'segment_id': type.StringType()})
        delete_0_error_dict = {'com.vmware.vapi.std.errors.service_unavailable'
            : type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_0_input_value_validator_list = []
        delete_0_output_validator_list = []
        delete_0_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template=
            '/policy/api/v1/infra/segments/{segment-id}?force=true',
            path_variables={'segment_id': 'segment-id'}, query_parameters={
            }, content_type='application/json')
        get_input_type = type.StructType('operation-input', {'segment_id':
            type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/segments/{segment-id}',
            path_variables={'segment_id': 'segment-id'}, query_parameters={
            }, content_type='application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/segments', path_variables={},
            query_parameters={'cursor': 'cursor',
            'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        patch_input_type = type.StructType('operation-input', {'segment_id':
            type.StringType(), 'segment': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'Segment')})
        patch_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        patch_input_value_validator_list = [HasFieldsOfValidator()]
        patch_output_validator_list = []
        patch_rest_metadata = OperationRestMetadata(http_method='PATCH',
            url_template='/policy/api/v1/infra/segments/{segment-id}',
            request_body_parameter='segment', path_variables={'segment_id':
            'segment-id'}, query_parameters={}, content_type='application/json'
            )
        update_input_type = type.StructType('operation-input', {
            'segment_id': type.StringType(), 'segment': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'Segment')})
        update_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(http_method='PUT',
            url_template='/policy/api/v1/infra/segments/{segment-id}',
            request_body_parameter='segment', path_variables={'segment_id':
            'segment-id'}, query_parameters={}, content_type='application/json'
            )
        operations = {'delete': {'input_type': delete_input_type,
            'output_type': type.VoidType(), 'errors': delete_error_dict,
            'input_value_validator_list': delete_input_value_validator_list,
            'output_validator_list': delete_output_validator_list,
            'task_type': TaskType.NONE}, 'delete_0': {'input_type':
            delete_0_input_type, 'output_type': type.VoidType(), 'errors':
            delete_0_error_dict, 'input_value_validator_list':
            delete_0_input_value_validator_list, 'output_validator_list':
            delete_0_output_validator_list, 'task_type': TaskType.NONE},
            'get': {'input_type': get_input_type, 'output_type': type.
            ReferenceType('com.vmware.nsx_policy.model_client', 'Segment'),
            'errors': get_error_dict, 'input_value_validator_list':
            get_input_value_validator_list, 'output_validator_list':
            get_output_validator_list, 'task_type': TaskType.NONE}, 'list':
            {'input_type': list_input_type, 'output_type': type.
            ReferenceType('com.vmware.nsx_policy.model_client',
            'SegmentListResult'), 'errors': list_error_dict,
            'input_value_validator_list': list_input_value_validator_list,
            'output_validator_list': list_output_validator_list,
            'task_type': TaskType.NONE}, 'patch': {'input_type':
            patch_input_type, 'output_type': type.VoidType(), 'errors':
            patch_error_dict, 'input_value_validator_list':
            patch_input_value_validator_list, 'output_validator_list':
            patch_output_validator_list, 'task_type': TaskType.NONE},
            'update': {'input_type': update_input_type, 'output_type': type
            .ReferenceType('com.vmware.nsx_policy.model_client', 'Segment'),
            'errors': update_error_dict, 'input_value_validator_list':
            update_input_value_validator_list, 'output_validator_list':
            update_output_validator_list, 'task_type': TaskType.NONE}}
        rest_metadata = {'delete': delete_rest_metadata, 'delete_0':
            delete_0_rest_metadata, 'get': get_rest_metadata, 'list':
            list_rest_metadata, 'patch': patch_rest_metadata, 'update':
            update_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.segments', config=config,
            operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)


class _ServicesStub(ApiInterfaceStub):

    def __init__(self, config):
        delete_input_type = type.StructType('operation-input', {
            'service_id': type.StringType()})
        delete_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template='/policy/api/v1/infra/services/{service-id}',
            path_variables={'service_id': 'service-id'}, query_parameters={
            }, content_type='application/json')
        get_input_type = type.StructType('operation-input', {'service_id':
            type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/services/{service-id}',
            path_variables={'service_id': 'service-id'}, query_parameters={
            }, content_type='application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()), 'default_service': type.
            OptionalType(type.BooleanType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/services', path_variables={},
            query_parameters={'cursor': 'cursor', 'default_service':
            'default_service', 'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        patch_input_type = type.StructType('operation-input', {'service_id':
            type.StringType(), 'service': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'Service')})
        patch_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        patch_input_value_validator_list = [HasFieldsOfValidator()]
        patch_output_validator_list = []
        patch_rest_metadata = OperationRestMetadata(http_method='PATCH',
            url_template='/policy/api/v1/infra/services/{service-id}',
            request_body_parameter='service', path_variables={'service_id':
            'service-id'}, query_parameters={}, content_type='application/json'
            )
        update_input_type = type.StructType('operation-input', {
            'service_id': type.StringType(), 'service': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'Service')})
        update_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(http_method='PUT',
            url_template='/policy/api/v1/infra/services/{service-id}',
            request_body_parameter='service', path_variables={'service_id':
            'service-id'}, query_parameters={}, content_type='application/json'
            )
        operations = {'delete': {'input_type': delete_input_type,
            'output_type': type.VoidType(), 'errors': delete_error_dict,
            'input_value_validator_list': delete_input_value_validator_list,
            'output_validator_list': delete_output_validator_list,
            'task_type': TaskType.NONE}, 'get': {'input_type':
            get_input_type, 'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'Service'), 'errors':
            get_error_dict, 'input_value_validator_list':
            get_input_value_validator_list, 'output_validator_list':
            get_output_validator_list, 'task_type': TaskType.NONE}, 'list':
            {'input_type': list_input_type, 'output_type': type.
            ReferenceType('com.vmware.nsx_policy.model_client',
            'ServiceListResult'), 'errors': list_error_dict,
            'input_value_validator_list': list_input_value_validator_list,
            'output_validator_list': list_output_validator_list,
            'task_type': TaskType.NONE}, 'patch': {'input_type':
            patch_input_type, 'output_type': type.VoidType(), 'errors':
            patch_error_dict, 'input_value_validator_list':
            patch_input_value_validator_list, 'output_validator_list':
            patch_output_validator_list, 'task_type': TaskType.NONE},
            'update': {'input_type': update_input_type, 'output_type': type
            .ReferenceType('com.vmware.nsx_policy.model_client', 'Service'),
            'errors': update_error_dict, 'input_value_validator_list':
            update_input_value_validator_list, 'output_validator_list':
            update_output_validator_list, 'task_type': TaskType.NONE}}
        rest_metadata = {'delete': delete_rest_metadata, 'get':
            get_rest_metadata, 'list': list_rest_metadata, 'patch':
            patch_rest_metadata, 'update': update_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.services', config=config,
            operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)


class StubFactory(StubFactoryBase):
    _attrs = {'DhcpRelayConfigs': DhcpRelayConfigs, 'DhcpServerConfigs':
        DhcpServerConfigs, 'DnsForwarderZones': DnsForwarderZones,
        'Domains': Domains, 'Drafts': Drafts, 'GroupAssociations':
        GroupAssociations, 'IpfixCollectorProfiles': IpfixCollectorProfiles,
        'IpfixDfwCollectorProfiles': IpfixDfwCollectorProfiles,
        'IpfixDfwProfiles': IpfixDfwProfiles, 'IpfixL2CollectorProfiles':
        IpfixL2CollectorProfiles, 'IpfixL2Profiles': IpfixL2Profiles,
        'IpsecVpnDpdProfiles': IpsecVpnDpdProfiles, 'IpsecVpnIkeProfiles':
        IpsecVpnIkeProfiles, 'IpsecVpnTunnelProfiles':
        IpsecVpnTunnelProfiles, 'PartnerServices': PartnerServices,
        'PortMirroringProfiles': PortMirroringProfiles, 'Segments':
        Segments, 'Services': Services, 'domains':
        'com.vmware.nsx_policy.infra.domains_client.StubFactory', 'drafts':
        'com.vmware.nsx_policy.infra.drafts_client.StubFactory',
        'realized_state':
        'com.vmware.nsx_policy.infra.realized_state_client.StubFactory',
        'segments':
        'com.vmware.nsx_policy.infra.segments_client.StubFactory',
        'services':
        'com.vmware.nsx_policy.infra.services_client.StubFactory', 'sites':
        'com.vmware.nsx_policy.infra.sites_client.StubFactory', 'tier_0s':
        'com.vmware.nsx_policy.infra.tier_0s_client.StubFactory', 'tier_1s':
        'com.vmware.nsx_policy.infra.tier_1s_client.StubFactory'}

<mask token>


class DhcpRelayConfigs(VapiInterface):
    <mask token>
    <mask token>
    <mask token>

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _DhcpRelayConfigsStub)
        self._VAPI_OPERATION_IDS = {}

    def delete(self, dhcp_relay_config_id):
        """
        Delete DHCP relay configuration

        :type  dhcp_relay_config_id: :class:`str`
        :param dhcp_relay_config_id: DHCP relay config ID (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete', {'dhcp_relay_config_id':
            dhcp_relay_config_id})

    def get(self, dhcp_relay_config_id):
        """
        Read DHCP relay configuration

        :type  dhcp_relay_config_id: :class:`str`
        :param dhcp_relay_config_id: DHCP relay config ID (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.DhcpRelayConfig`
        :return: com.vmware.nsx_policy.model.DhcpRelayConfig
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'dhcp_relay_config_id':
            dhcp_relay_config_id})
    <mask token>

    def patch(self, dhcp_relay_config_id, dhcp_relay_config):
        """
        If DHCP relay config with the dhcp-relay-config-id is not already
        present, create a new DHCP relay config instance. If it already exists,
        update the DHCP relay config instance with specified attributes.

        :type  dhcp_relay_config_id: :class:`str`
        :param dhcp_relay_config_id: DHCP relay config ID (required)
        :type  dhcp_relay_config: :class:`com.vmware.nsx_policy.model_client.DhcpRelayConfig`
        :param dhcp_relay_config: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch', {'dhcp_relay_config_id':
            dhcp_relay_config_id, 'dhcp_relay_config': dhcp_relay_config})
    <mask token>


class DhcpServerConfigs(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.dhcp_server_configs'
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _DhcpServerConfigsStub)
        self._VAPI_OPERATION_IDS = {}

    def delete(self, dhcp_server_config_id):
        """
        Delete DHCP server configuration

        :type  dhcp_server_config_id: :class:`str`
        :param dhcp_server_config_id: DHCP server config ID (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete', {'dhcp_server_config_id':
            dhcp_server_config_id})

    def get(self, dhcp_server_config_id):
        """
        Read DHCP server configuration

        :type  dhcp_server_config_id: :class:`str`
        :param dhcp_server_config_id: DHCP server config ID (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.DhcpServerConfig`
        :return: com.vmware.nsx_policy.model.DhcpServerConfig
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'dhcp_server_config_id':
            dhcp_server_config_id})

    def list(self, cursor=None, include_mark_for_delete_objects=None,
        included_fields=None, page_size=None, sort_ascending=None, sort_by=None
        ):
        """
        Paginated list of all DHCP server config instances

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.DhcpServerConfigListResult`
        :return: com.vmware.nsx_policy.model.DhcpServerConfigListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'cursor': cursor,
            'include_mark_for_delete_objects':
            include_mark_for_delete_objects, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})

    def patch(self, dhcp_server_config_id, dhcp_server_config):
        """
        If DHCP server config with the dhcp-server-config-id is not already
        present, create a new DHCP server config instance. If it already
        exists, update the DHCP server config instance with specified
        attributes. Realized entities of this API can be found using the path
        of Tier-0 that this config is applied on.

        :type  dhcp_server_config_id: :class:`str`
        :param dhcp_server_config_id: DHCP server config ID (required)
        :type  dhcp_server_config: :class:`com.vmware.nsx_policy.model_client.DhcpServerConfig`
        :param dhcp_server_config: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch', {'dhcp_server_config_id':
            dhcp_server_config_id, 'dhcp_server_config': dhcp_server_config})

    def update(self, dhcp_server_config_id, dhcp_server_config):
        """
        If DHCP server config with the dhcp-server-config-id is not already
        present, create a new DHCP server config instance. If it already
        exists, replace the DHCP server config instance with this object.
        Realized entities of this API can be found using the path of Tier-0
        that this config is applied on.

        :type  dhcp_server_config_id: :class:`str`
        :param dhcp_server_config_id: DHCP server config ID (required)
        :type  dhcp_server_config: :class:`com.vmware.nsx_policy.model_client.DhcpServerConfig`
        :param dhcp_server_config: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.DhcpServerConfig`
        :return: com.vmware.nsx_policy.model.DhcpServerConfig
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update', {'dhcp_server_config_id':
            dhcp_server_config_id, 'dhcp_server_config': dhcp_server_config})


class DnsForwarderZones(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.dns_forwarder_zones'
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _DnsForwarderZonesStub)
        self._VAPI_OPERATION_IDS = {}

    def delete(self, dns_forwarder_zone_id):
        """
        Delete the DNS Forwarder Zone

        :type  dns_forwarder_zone_id: :class:`str`
        :param dns_forwarder_zone_id: DNS Forwarder Zone ID (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete', {'dns_forwarder_zone_id':
            dns_forwarder_zone_id})

    def get(self, dns_forwarder_zone_id):
        """
        Read the DNS Forwarder Zone

        :type  dns_forwarder_zone_id: :class:`str`
        :param dns_forwarder_zone_id: DNS Forwarder Zone ID (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.PolicyDnsForwarderZone`
        :return: com.vmware.nsx_policy.model.PolicyDnsForwarderZone
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'dns_forwarder_zone_id':
            dns_forwarder_zone_id})

    def list(self, cursor=None, include_mark_for_delete_objects=None,
        included_fields=None, page_size=None, sort_ascending=None, sort_by=None
        ):
        """
        Paginated list of all Dns Forwarder Zones

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.PolicyDnsForwarderZoneListResult`
        :return: com.vmware.nsx_policy.model.PolicyDnsForwarderZoneListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'cursor': cursor,
            'include_mark_for_delete_objects':
            include_mark_for_delete_objects, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})

    def patch(self, dns_forwarder_zone_id, policy_dns_forwarder_zone):
        """
        Create or update the DNS Forwarder Zone

        :type  dns_forwarder_zone_id: :class:`str`
        :param dns_forwarder_zone_id: DNS Forwarder Zone ID (required)
        :type  policy_dns_forwarder_zone: :class:`com.vmware.nsx_policy.model_client.PolicyDnsForwarderZone`
        :param policy_dns_forwarder_zone: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch', {'dns_forwarder_zone_id':
            dns_forwarder_zone_id, 'policy_dns_forwarder_zone':
            policy_dns_forwarder_zone})

    def update(self, dns_forwarder_zone_id, policy_dns_forwarder_zone):
        """
        Create or update the DNS Forwarder Zone

        :type  dns_forwarder_zone_id: :class:`str`
        :param dns_forwarder_zone_id: DNS Forwarder Zone ID (required)
        :type  policy_dns_forwarder_zone: :class:`com.vmware.nsx_policy.model_client.PolicyDnsForwarderZone`
        :param policy_dns_forwarder_zone: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.PolicyDnsForwarderZone`
        :return: com.vmware.nsx_policy.model.PolicyDnsForwarderZone
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update', {'dns_forwarder_zone_id':
            dns_forwarder_zone_id, 'policy_dns_forwarder_zone':
            policy_dns_forwarder_zone})


class Domains(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.domains'
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _DomainsStub)
        self._VAPI_OPERATION_IDS = {}

    def get(self, domain_id):
        """
        Read a domain.

        :type  domain_id: :class:`str`
        :param domain_id: Domain ID (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.Domain`
        :return: com.vmware.nsx_policy.model.Domain
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'domain_id': domain_id})

    def list(self, cursor=None, include_mark_for_delete_objects=None,
        included_fields=None, page_size=None, sort_ascending=None, sort_by=None
        ):
        """
        Paginated list of all domains for infra.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.DomainListResult`
        :return: com.vmware.nsx_policy.model.DomainListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'cursor': cursor,
            'include_mark_for_delete_objects':
            include_mark_for_delete_objects, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})


class Drafts(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.drafts'
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _DraftsStub)
        self._VAPI_OPERATION_IDS = {}

    def abort(self, draft_id):
        """
        If there is a failure during publish, the admin can choose to abort the
        publishing attempts. This will bring back the system to the current
        configuration, i.e just before the publish was invoked. If draft
        publishing is not in progress or already completed, then this is a
        NO-OP

        :type  draft_id: :class:`str`
        :param draft_id: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('abort', {'draft_id': draft_id})

    def delete(self, draft_id):
        """
        Delete a manual draft.

        :type  draft_id: :class:`str`
        :param draft_id: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete', {'draft_id': draft_id})

    def get(self, draft_id):
        """
        Read a draft for a given draft identifier.

        :type  draft_id: :class:`str`
        :param draft_id: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.PolicyDraft`
        :return: com.vmware.nsx_policy.model.PolicyDraft
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'draft_id': draft_id})

    def list(self, auto_drafts=None, cursor=None,
        include_mark_for_delete_objects=None, included_fields=None,
        page_size=None, sort_ascending=None, sort_by=None):
        """
        List policy drafts.

        :type  auto_drafts: :class:`bool` or ``None``
        :param auto_drafts: Fetch list of draft based on is_auto_draft flag (optional)
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.PolicyDraftListResult`
        :return: com.vmware.nsx_policy.model.PolicyDraftListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'auto_drafts': auto_drafts, 'cursor':
            cursor, 'include_mark_for_delete_objects':
            include_mark_for_delete_objects, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})

    def patch(self, draft_id, policy_draft):
        """
        Create a new manual draft if the specified draft id does not correspond
        to an existing draft. Update the manual draft otherwise. Auto draft can
        not be updated.

        :type  draft_id: :class:`str`
        :param draft_id: (required)
        :type  policy_draft: :class:`com.vmware.nsx_policy.model_client.PolicyDraft`
        :param policy_draft: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch', {'draft_id': draft_id, 'policy_draft':
            policy_draft})

    def publish(self, draft_id, infra):
        """
        Read a draft and publish it by applying changes onto current
        configuration.

        :type  draft_id: :class:`str`
        :param draft_id: (required)
        :type  infra: :class:`com.vmware.nsx_policy.model_client.Infra`
        :param infra: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('publish', {'draft_id': draft_id, 'infra': infra})

    def update(self, draft_id, policy_draft):
        """
        Create a new manual draft if the specified draft id does not correspond
        to an existing draft. Update the manual draft otherwise. Auto draft can
        not be updated.

        :type  draft_id: :class:`str`
        :param draft_id: (required)
        :type  policy_draft: :class:`com.vmware.nsx_policy.model_client.PolicyDraft`
        :param policy_draft: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.PolicyDraft`
        :return: com.vmware.nsx_policy.model.PolicyDraft
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update', {'draft_id': draft_id, 'policy_draft':
            policy_draft})


class GroupAssociations(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.group_associations'
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _GroupAssociationsStub)
        self._VAPI_OPERATION_IDS = {}

    def list(self, intent_path, cursor=None, enforcement_point_path=None,
        include_mark_for_delete_objects=None, included_fields=None,
        page_size=None, sort_ascending=None, sort_by=None):
        """
        Get policy groups for which the given object is a member.

        :type  intent_path: :class:`str`
        :param intent_path: String path of the intent object (required)
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  enforcement_point_path: :class:`str` or ``None``
        :param enforcement_point_path: String Path of the enforcement point (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.PolicyResourceReferenceForEPListResult`
        :return: com.vmware.nsx_policy.model.PolicyResourceReferenceForEPListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'intent_path': intent_path, 'cursor':
            cursor, 'enforcement_point_path': enforcement_point_path,
            'include_mark_for_delete_objects':
            include_mark_for_delete_objects, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})


class IpfixCollectorProfiles(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.ipfix_collector_profiles'
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _IpfixCollectorProfilesStub)
        self._VAPI_OPERATION_IDS = {}

    def delete(self, ipfix_collector_profile_id):
        """
        API deletes IPFIX collector profile. Flow forwarding to collector will
        be stopped. This API is deprecated. Please use the following API:
        https://<policy-mgr>/policy/api/v1/infra/ipfix-l2-collector-profiles

        :type  ipfix_collector_profile_id: :class:`str`
        :param ipfix_collector_profile_id: IPFIX collector Profile id (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete', {'ipfix_collector_profile_id':
            ipfix_collector_profile_id})

    def get(self, ipfix_collector_profile_id):
        """
        API will return details of IPFIX collector profile. If profile does not
        exist, it will return 404. This API is deprecated. Please use the
        following API:
        https://<policy-mgr>/policy/api/v1/infra/ipfix-l2-collector-profiles

        :type  ipfix_collector_profile_id: :class:`str`
        :param ipfix_collector_profile_id: IPFIX collector profile id (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXCollectorProfile`
        :return: com.vmware.nsx_policy.model.IPFIXCollectorProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'ipfix_collector_profile_id':
            ipfix_collector_profile_id})

    def list(self, cursor=None, include_mark_for_delete_objects=None,
        included_fields=None, page_size=None, sort_ascending=None, sort_by=None
        ):
        """
        API will provide list of all IPFIX collector profiles and their
        details. This API is deprecated. Please use the following API:
        https://<policy-mgr>/policy/api/v1/infra/ipfix-l2-collector-profiles

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXCollectorProfileListResult`
        :return: com.vmware.nsx_policy.model.IPFIXCollectorProfileListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'cursor': cursor,
            'include_mark_for_delete_objects':
            include_mark_for_delete_objects, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})

    def patch(self, ipfix_collector_profile_id, i_pfix_collector_profile):
        """
        Create a new IPFIX collector profile if the IPFIX collector profile
        with given id does not already exist. If the IPFIX collector profile
        with the given id already exists, patch with the existing IPFIX
        collector profile. This API is deprecated. Please use the following
        API:
        https://<policy-mgr>/policy/api/v1/infra/ipfix-l2-collector-profiles

        :type  ipfix_collector_profile_id: :class:`str`
        :param ipfix_collector_profile_id: IPFIX collector profile id (required)
        :type  i_pfix_collector_profile: :class:`com.vmware.nsx_policy.model_client.IPFIXCollectorProfile`
        :param i_pfix_collector_profile: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch', {'ipfix_collector_profile_id':
            ipfix_collector_profile_id, 'i_pfix_collector_profile':
            i_pfix_collector_profile})

    def update(self, ipfix_collector_profile_id, i_pfix_collector_profile):
        """
        Create or Replace IPFIX collector profile. IPFIX data will be sent to
        IPFIX collector port. This API is deprecated. Please use the following
        API:
        https://<policy-mgr>/policy/api/v1/infra/ipfix-l2-collector-profiles

        :type  ipfix_collector_profile_id: :class:`str`
        :param ipfix_collector_profile_id: IPFIX collector profile id (required)
        :type  i_pfix_collector_profile: :class:`com.vmware.nsx_policy.model_client.IPFIXCollectorProfile`
        :param i_pfix_collector_profile: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXCollectorProfile`
        :return: com.vmware.nsx_policy.model.IPFIXCollectorProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update', {'ipfix_collector_profile_id':
            ipfix_collector_profile_id, 'i_pfix_collector_profile':
            i_pfix_collector_profile})


class IpfixDfwCollectorProfiles(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = (
        'com.vmware.nsx_policy.infra.ipfix_dfw_collector_profiles')
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _IpfixDfwCollectorProfilesStub)
        self._VAPI_OPERATION_IDS = {}

    def delete(self, ipfix_dfw_collector_profile_id):
        """
        API deletes IPFIX dfw collector profile. Flow forwarding to collector
        will be stopped.

        :type  ipfix_dfw_collector_profile_id: :class:`str`
        :param ipfix_dfw_collector_profile_id: IPFIX dfw collector Profile id (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete', {'ipfix_dfw_collector_profile_id':
            ipfix_dfw_collector_profile_id})

    def get(self, ipfix_dfw_collector_profile_id):
        """
        API will return details of IPFIX dfw collector profile. If profile does
        not exist, it will return 404.

        :type  ipfix_dfw_collector_profile_id: :class:`str`
        :param ipfix_dfw_collector_profile_id: IPFIX dfw collector profile id (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXDFWCollectorProfile`
        :return: com.vmware.nsx_policy.model.IPFIXDFWCollectorProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'ipfix_dfw_collector_profile_id':
            ipfix_dfw_collector_profile_id})

    def list(self, cursor=None, include_mark_for_delete_objects=None,
        included_fields=None, page_size=None, sort_ascending=None, sort_by=None
        ):
        """
        API will provide list of all IPFIX dfw collector profiles and their
        details.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXDFWCollectorProfileListResult`
        :return: com.vmware.nsx_policy.model.IPFIXDFWCollectorProfileListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'cursor': cursor,
            'include_mark_for_delete_objects':
            include_mark_for_delete_objects, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})

    def patch(self, ipfix_dfw_collector_profile_id, i_pfixdfw_collector_profile
        ):
        """
        Create a new IPFIX dfw collector profile if the IPFIX dfw collector
        profile with given id does not already exist. If the IPFIX dfw
        collector profile with the given id already exists, patch with the
        existing IPFIX dfw collector profile.

        :type  ipfix_dfw_collector_profile_id: :class:`str`
        :param ipfix_dfw_collector_profile_id: (required)
        :type  i_pfixdfw_collector_profile: :class:`com.vmware.nsx_policy.model_client.IPFIXDFWCollectorProfile`
        :param i_pfixdfw_collector_profile: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch', {'ipfix_dfw_collector_profile_id':
            ipfix_dfw_collector_profile_id, 'i_pfixdfw_collector_profile':
            i_pfixdfw_collector_profile})

    def update(self, ipfix_dfw_collector_profile_id,
        i_pfixdfw_collector_profile):
        """
        Create or Replace IPFIX dfw collector profile. IPFIX data will be sent
        to IPFIX collector port.

        :type  ipfix_dfw_collector_profile_id: :class:`str`
        :param ipfix_dfw_collector_profile_id: IPFIX dfw collector profile id (required)
        :type  i_pfixdfw_collector_profile: :class:`com.vmware.nsx_policy.model_client.IPFIXDFWCollectorProfile`
        :param i_pfixdfw_collector_profile: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXDFWCollectorProfile`
        :return: com.vmware.nsx_policy.model.IPFIXDFWCollectorProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update', {'ipfix_dfw_collector_profile_id':
            ipfix_dfw_collector_profile_id, 'i_pfixdfw_collector_profile':
            i_pfixdfw_collector_profile})


class IpfixDfwProfiles(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.ipfix_dfw_profiles'
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _IpfixDfwProfilesStub)
        self._VAPI_OPERATION_IDS = {}

    def delete(self, ipfix_dfw_profile_id):
        """
        API deletes IPFIX DFW Profile. Selected IPFIX Collectors will stop
        receiving flows.

        :type  ipfix_dfw_profile_id: :class:`str`
        :param ipfix_dfw_profile_id: IPFIX DFW Profile ID (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete', {'ipfix_dfw_profile_id':
            ipfix_dfw_profile_id})

    def get(self, ipfix_dfw_profile_id):
        """
        API will return details of IPFIX DFW profile.

        :type  ipfix_dfw_profile_id: :class:`str`
        :param ipfix_dfw_profile_id: IPFIX DFW collection id (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXDFWProfile`
        :return: com.vmware.nsx_policy.model.IPFIXDFWProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'ipfix_dfw_profile_id':
            ipfix_dfw_profile_id})

    def list(self, cursor=None, include_mark_for_delete_objects=None,
        included_fields=None, page_size=None, sort_ascending=None, sort_by=None
        ):
        """
        API provides list IPFIX DFW profiles available on selected logical DFW.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXDFWProfileListResult`
        :return: com.vmware.nsx_policy.model.IPFIXDFWProfileListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'cursor': cursor,
            'include_mark_for_delete_objects':
            include_mark_for_delete_objects, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})

    def patch(self, ipfix_dfw_profile_id, i_pfixdfw_profile):
        """
        Create a new IPFIX DFW profile if the IPFIX DFW profile with given id
        does not already exist. If the IPFIX DFW profile with the given id
        already exists, patch with the existing IPFIX DFW profile.

        :type  ipfix_dfw_profile_id: :class:`str`
        :param ipfix_dfw_profile_id: IPFIX DFW Profile ID (required)
        :type  i_pfixdfw_profile: :class:`com.vmware.nsx_policy.model_client.IPFIXDFWProfile`
        :param i_pfixdfw_profile: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch', {'ipfix_dfw_profile_id':
            ipfix_dfw_profile_id, 'i_pfixdfw_profile': i_pfixdfw_profile})

    def update(self, ipfix_dfw_profile_id, i_pfixdfw_profile):
        """
        Create or replace IPFIX DFW profile. Config will start forwarding data
        to provided IPFIX DFW collector.

        :type  ipfix_dfw_profile_id: :class:`str`
        :param ipfix_dfw_profile_id: IPFIX DFW Profile ID (required)
        :type  i_pfixdfw_profile: :class:`com.vmware.nsx_policy.model_client.IPFIXDFWProfile`
        :param i_pfixdfw_profile: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXDFWProfile`
        :return: com.vmware.nsx_policy.model.IPFIXDFWProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update', {'ipfix_dfw_profile_id':
            ipfix_dfw_profile_id, 'i_pfixdfw_profile': i_pfixdfw_profile})


class IpfixL2CollectorProfiles(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = (
        'com.vmware.nsx_policy.infra.ipfix_l2_collector_profiles')
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _IpfixL2CollectorProfilesStub)
        self._VAPI_OPERATION_IDS = {}

    def delete(self, ipfix_l2_collector_profile_id):
        """
        API deletes IPFIX collector profile. Flow forwarding to collector will
        be stopped.

        :type  ipfix_l2_collector_profile_id: :class:`str`
        :param ipfix_l2_collector_profile_id: IPFIX collector Profile id (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete', {'ipfix_l2_collector_profile_id':
            ipfix_l2_collector_profile_id})

    def get(self, ipfix_l2_collector_profile_id):
        """
        API will return details of IPFIX collector profile.

        :type  ipfix_l2_collector_profile_id: :class:`str`
        :param ipfix_l2_collector_profile_id: IPFIX collector profile id (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXL2CollectorProfile`
        :return: com.vmware.nsx_policy.model.IPFIXL2CollectorProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'ipfix_l2_collector_profile_id':
            ipfix_l2_collector_profile_id})

    def list(self, cursor=None, include_mark_for_delete_objects=None,
        included_fields=None, page_size=None, sort_ascending=None, sort_by=None
        ):
        """
        API will provide list of all IPFIX collector profiles and their
        details.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXL2CollectorProfileListResult`
        :return: com.vmware.nsx_policy.model.IPFIXL2CollectorProfileListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'cursor': cursor,
            'include_mark_for_delete_objects':
            include_mark_for_delete_objects, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})

    def patch(self, ipfix_l2_collector_profile_id, i_pfix_l2_collector_profile
        ):
        """
        Create a new IPFIX collector profile if the IPFIX collector profile
        with given id does not already exist. If the IPFIX collector profile
        with the given id already exists, patch with the existing IPFIX
        collector profile.

        :type  ipfix_l2_collector_profile_id: :class:`str`
        :param ipfix_l2_collector_profile_id: IPFIX collector profile id (required)
        :type  i_pfix_l2_collector_profile: :class:`com.vmware.nsx_policy.model_client.IPFIXL2CollectorProfile`
        :param i_pfix_l2_collector_profile: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch', {'ipfix_l2_collector_profile_id':
            ipfix_l2_collector_profile_id, 'i_pfix_l2_collector_profile':
            i_pfix_l2_collector_profile})

    def update(self, ipfix_l2_collector_profile_id, i_pfix_l2_collector_profile
        ):
        """
        Create or Replace IPFIX collector profile. IPFIX data will be sent to
        IPFIX collector.

        :type  ipfix_l2_collector_profile_id: :class:`str`
        :param ipfix_l2_collector_profile_id: IPFIX collector profile id (required)
        :type  i_pfix_l2_collector_profile: :class:`com.vmware.nsx_policy.model_client.IPFIXL2CollectorProfile`
        :param i_pfix_l2_collector_profile: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXL2CollectorProfile`
        :return: com.vmware.nsx_policy.model.IPFIXL2CollectorProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update', {'ipfix_l2_collector_profile_id':
            ipfix_l2_collector_profile_id, 'i_pfix_l2_collector_profile':
            i_pfix_l2_collector_profile})


class IpfixL2Profiles(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.ipfix_l2_profiles'
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _IpfixL2ProfilesStub)
        self._VAPI_OPERATION_IDS = {}

    def delete(self, ipfix_l2_profile_id):
        """
        API deletes IPFIX L2 Profile. Flow forwarding to selected collector
        will be stopped.

        :type  ipfix_l2_profile_id: :class:`str`
        :param ipfix_l2_profile_id: IPFIX L2 Profile ID (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete', {'ipfix_l2_profile_id':
            ipfix_l2_profile_id})

    def get(self, ipfix_l2_profile_id):
        """
        API will return details of IPFIX L2 profile.

        :type  ipfix_l2_profile_id: :class:`str`
        :param ipfix_l2_profile_id: IPFIX L2 profile id (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXL2Profile`
        :return: com.vmware.nsx_policy.model.IPFIXL2Profile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'ipfix_l2_profile_id': ipfix_l2_profile_id}
            )

    def list(self, cursor=None, include_mark_for_delete_objects=None,
        included_fields=None, page_size=None, sort_ascending=None, sort_by=None
        ):
        """
        API provides list IPFIX L2 Profiles available on selected logical l2.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXL2ProfileListResult`
        :return: com.vmware.nsx_policy.model.IPFIXL2ProfileListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'cursor': cursor,
            'include_mark_for_delete_objects':
            include_mark_for_delete_objects, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})

    def patch(self, ipfix_l2_profile_id, i_pfix_l2_profile):
        """
        Create a new IPFIX L2 profile if the IPFIX L2 profile with given id
        does not already exist. If the IPFIX L2 profile with the given id
        already exists, patch with the existing IPFIX L2 profile.

        :type  ipfix_l2_profile_id: :class:`str`
        :param ipfix_l2_profile_id: IPFIX L2 Profile ID (required)
        :type  i_pfix_l2_profile: :class:`com.vmware.nsx_policy.model_client.IPFIXL2Profile`
        :param i_pfix_l2_profile: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch', {'ipfix_l2_profile_id':
            ipfix_l2_profile_id, 'i_pfix_l2_profile': i_pfix_l2_profile})

    def update(self, ipfix_l2_profile_id, i_pfix_l2_profile):
        """
        Create or replace IPFIX L2 Profile. Profile is reusable entity. Single
        profile can attached multiple bindings e.g group, segment and port.

        :type  ipfix_l2_profile_id: :class:`str`
        :param ipfix_l2_profile_id: IPFIX L2 Profile ID (required)
        :type  i_pfix_l2_profile: :class:`com.vmware.nsx_policy.model_client.IPFIXL2Profile`
        :param i_pfix_l2_profile: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXL2Profile`
        :return: com.vmware.nsx_policy.model.IPFIXL2Profile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update', {'ipfix_l2_profile_id':
            ipfix_l2_profile_id, 'i_pfix_l2_profile': i_pfix_l2_profile})


class IpsecVpnDpdProfiles(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.ipsec_vpn_dpd_profiles'
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _IpsecVpnDpdProfilesStub)
        self._VAPI_OPERATION_IDS = {}

    def delete(self, dpd_profile_id):
        """
        Delete custom dead peer detection (DPD) profile. Profile can not be
        deleted if profile has references to it.

        :type  dpd_profile_id: :class:`str`
        :param dpd_profile_id: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete', {'dpd_profile_id': dpd_profile_id})

    def get(self, dpd_profile_id):
        """
        Get custom dead peer detection (DPD) profile, given the particular id.

        :type  dpd_profile_id: :class:`str`
        :param dpd_profile_id: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPSecVpnDpdProfile`
        :return: com.vmware.nsx_policy.model.IPSecVpnDpdProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'dpd_profile_id': dpd_profile_id})

    def list(self, cursor=None, include_mark_for_delete_objects=None,
        included_fields=None, page_size=None, sort_ascending=None, sort_by=None
        ):
        """
        Get paginated list of all DPD Profiles.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPSecVpnDpdProfileListResult`
        :return: com.vmware.nsx_policy.model.IPSecVpnDpdProfileListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'cursor': cursor,
            'include_mark_for_delete_objects':
            include_mark_for_delete_objects, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})

    def patch(self, dpd_profile_id, ip_sec_vpn_dpd_profile):
        """
        Create or patch dead peer detection (DPD) profile. Any change in
        profile affects all sessions consuming this profile. System will be
        provisioned with system owned editable default DPD profile. Any change
        in profile affects all sessions consuming this profile.

        :type  dpd_profile_id: :class:`str`
        :param dpd_profile_id: (required)
        :type  ip_sec_vpn_dpd_profile: :class:`com.vmware.nsx_policy.model_client.IPSecVpnDpdProfile`
        :param ip_sec_vpn_dpd_profile: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch', {'dpd_profile_id': dpd_profile_id,
            'ip_sec_vpn_dpd_profile': ip_sec_vpn_dpd_profile})

    def update(self, dpd_profile_id, ip_sec_vpn_dpd_profile):
        """
        Create or patch dead peer detection (DPD) profile. Any change in
        profile affects all sessions consuming this profile. System will be
        provisioned with system owned editable default DPD profile. Any change
        in profile affects all sessions consuming this profile. Revision is
        optional for creation and required for update.

        :type  dpd_profile_id: :class:`str`
        :param dpd_profile_id: (required)
        :type  ip_sec_vpn_dpd_profile: :class:`com.vmware.nsx_policy.model_client.IPSecVpnDpdProfile`
        :param ip_sec_vpn_dpd_profile: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPSecVpnDpdProfile`
        :return: com.vmware.nsx_policy.model.IPSecVpnDpdProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update', {'dpd_profile_id': dpd_profile_id,
            'ip_sec_vpn_dpd_profile': ip_sec_vpn_dpd_profile})


class IpsecVpnIkeProfiles(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.ipsec_vpn_ike_profiles'
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _IpsecVpnIkeProfilesStub)
        self._VAPI_OPERATION_IDS = {}

    def delete(self, ike_profile_id):
        """
        Delete custom IKE Profile. Profile can not be deleted if profile has
        references to it.

        :type  ike_profile_id: :class:`str`
        :param ike_profile_id: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete', {'ike_profile_id': ike_profile_id})

    def get(self, ike_profile_id):
        """
        Get custom IKE Profile, given the particular id.

        :type  ike_profile_id: :class:`str`
        :param ike_profile_id: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPSecVpnIkeProfile`
        :return: com.vmware.nsx_policy.model.IPSecVpnIkeProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'ike_profile_id': ike_profile_id})

    def list(self, cursor=None, include_mark_for_delete_objects=None,
        included_fields=None, page_size=None, sort_ascending=None, sort_by=None
        ):
        """
        Get paginated list of all IKE Profiles.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPSecVpnIkeProfileListResult`
        :return: com.vmware.nsx_policy.model.IPSecVpnIkeProfileListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'cursor': cursor,
            'include_mark_for_delete_objects':
            include_mark_for_delete_objects, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})

    def patch(self, ike_profile_id, ip_sec_vpn_ike_profile):
        """
        Create or patch custom internet key exchange (IKE) Profile. IKE Profile
        is a reusable profile that captures IKE and phase one negotiation
        parameters. System will be pre provisioned with system owned editable
        default IKE profile and suggested set of profiles that can be used for
        peering with popular remote peers like AWS VPN. User can create custom
        profiles as needed. Any change in profile affects all sessions
        consuming this profile.

        :type  ike_profile_id: :class:`str`
        :param ike_profile_id: (required)
        :type  ip_sec_vpn_ike_profile: :class:`com.vmware.nsx_policy.model_client.IPSecVpnIkeProfile`
        :param ip_sec_vpn_ike_profile: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch', {'ike_profile_id': ike_profile_id,
            'ip_sec_vpn_ike_profile': ip_sec_vpn_ike_profile})

    def update(self, ike_profile_id, ip_sec_vpn_ike_profile):
        """
        Create or fully replace custom internet key exchange (IKE) Profile. IKE
        Profile is a reusable profile that captures IKE and phase one
        negotiation parameters. System will be pre provisioned with system
        owned editable default IKE profile and suggested set of profiles that
        can be used for peering with popular remote peers like AWS VPN. User
        can create custom profiles as needed. Any change in profile affects all
        sessions consuming this profile. Revision is optional for creation and
        required for update.

        :type  ike_profile_id: :class:`str`
        :param ike_profile_id: (required)
        :type  ip_sec_vpn_ike_profile: :class:`com.vmware.nsx_policy.model_client.IPSecVpnIkeProfile`
        :param ip_sec_vpn_ike_profile: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPSecVpnIkeProfile`
        :return: com.vmware.nsx_policy.model.IPSecVpnIkeProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update', {'ike_profile_id': ike_profile_id,
            'ip_sec_vpn_ike_profile': ip_sec_vpn_ike_profile})


class IpsecVpnTunnelProfiles(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.ipsec_vpn_tunnel_profiles'
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _IpsecVpnTunnelProfilesStub)
        self._VAPI_OPERATION_IDS = {}

    def delete(self, tunnel_profile_id):
        """
        Delete custom IPSec tunnel Profile. Profile can not be deleted if
        profile has references to it.

        :type  tunnel_profile_id: :class:`str`
        :param tunnel_profile_id: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete', {'tunnel_profile_id': tunnel_profile_id})

    def get(self, tunnel_profile_id):
        """
        Get custom IPSec tunnel Profile, given the particular id.

        :type  tunnel_profile_id: :class:`str`
        :param tunnel_profile_id: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPSecVpnTunnelProfile`
        :return: com.vmware.nsx_policy.model.IPSecVpnTunnelProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'tunnel_profile_id': tunnel_profile_id})

    def list(self, cursor=None, include_mark_for_delete_objects=None,
        included_fields=None, page_size=None, sort_ascending=None, sort_by=None
        ):
        """
        Get paginated list of all IPSec tunnel Profiles.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPSecVpnTunnelProfileListResult`
        :return: com.vmware.nsx_policy.model.IPSecVpnTunnelProfileListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'cursor': cursor,
            'include_mark_for_delete_objects':
            include_mark_for_delete_objects, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})

    def patch(self, tunnel_profile_id, ip_sec_vpn_tunnel_profile):
        """
        Create or patch custom IPSec tunnel profile. IPSec tunnel profile is a
        reusable profile that captures phase two negotiation parameters and
        tunnel properties. System will be provisioned with system owned
        editable default IPSec tunnel profile. Any change in profile affects
        all sessions consuming this profile.

        :type  tunnel_profile_id: :class:`str`
        :param tunnel_profile_id: (required)
        :type  ip_sec_vpn_tunnel_profile: :class:`com.vmware.nsx_policy.model_client.IPSecVpnTunnelProfile`
        :param ip_sec_vpn_tunnel_profile: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch', {'tunnel_profile_id':
            tunnel_profile_id, 'ip_sec_vpn_tunnel_profile':
            ip_sec_vpn_tunnel_profile})

    def update(self, tunnel_profile_id, ip_sec_vpn_tunnel_profile):
        """
        Create or fully replace custom IPSec tunnel profile. IPSec tunnel
        profile is a reusable profile that captures phase two negotiation
        parameters and tunnel properties. System will be provisioned with
        system owned editable default IPSec tunnel profile. Any change in
        profile affects all sessions consuming this profile. Revision is
        optional for creation and required for update.

        :type  tunnel_profile_id: :class:`str`
        :param tunnel_profile_id: (required)
        :type  ip_sec_vpn_tunnel_profile: :class:`com.vmware.nsx_policy.model_client.IPSecVpnTunnelProfile`
        :param ip_sec_vpn_tunnel_profile: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPSecVpnTunnelProfile`
        :return: com.vmware.nsx_policy.model.IPSecVpnTunnelProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update', {'tunnel_profile_id':
            tunnel_profile_id, 'ip_sec_vpn_tunnel_profile':
            ip_sec_vpn_tunnel_profile})


class PartnerServices(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.partner_services'
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _PartnerServicesStub)
        self._VAPI_OPERATION_IDS = {}

    def get(self, service_name):
        """
        Read the specific partner service identified by provided name.

        :type  service_name: :class:`str`
        :param service_name: Name of the service (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.ServiceDefinition`
        :return: com.vmware.nsx_policy.model.ServiceDefinition
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'service_name': service_name})

    def list(self, cursor=None, include_mark_for_delete_objects=None,
        included_fields=None, page_size=None, sort_ascending=None, sort_by=None
        ):
        """
        Read all the partner services available for service insertion

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.ServiceInsertionServiceListResult`
        :return: com.vmware.nsx_policy.model.ServiceInsertionServiceListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'cursor': cursor,
            'include_mark_for_delete_objects':
            include_mark_for_delete_objects, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})


class PortMirroringProfiles(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.port_mirroring_profiles'
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _PortMirroringProfilesStub)
        self._VAPI_OPERATION_IDS = {}

    def delete(self, port_mirroring_profile_id):
        """
        API will delete port mirroring profile. Mirroring from source to
        destination ports will be stopped.

        :type  port_mirroring_profile_id: :class:`str`
        :param port_mirroring_profile_id: Port Mirroring Profile Id (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete', {'port_mirroring_profile_id':
            port_mirroring_profile_id})

    def get(self, port_mirroring_profile_id):
        """
        API will return details of port mirroring profile.

        :type  port_mirroring_profile_id: :class:`str`
        :param port_mirroring_profile_id: Port Mirroring Profile Id (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.PortMirroringProfile`
        :return: com.vmware.nsx_policy.model.PortMirroringProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'port_mirroring_profile_id':
            port_mirroring_profile_id})

    def list(self, cursor=None, included_fields=None, page_size=None,
        sort_ascending=None, sort_by=None):
        """
        API will list all port mirroring profiles group.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.PortMirroringProfileListResult`
        :return: com.vmware.nsx_policy.model.PortMirroringProfileListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'cursor': cursor, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})

    def patch(self, port_mirroring_profile_id, port_mirroring_profile):
        """
        Create a new Port Mirroring Profile if the Port Mirroring Profile with
        given id does not already exist. If the Port Mirroring Profile with the
        given id already exists, patch with the existing Port Mirroring
        Profile. Realized entities of this API can be found using the path of
        monitoring profile binding map that is used to apply this profile.

        :type  port_mirroring_profile_id: :class:`str`
        :param port_mirroring_profile_id: Port Mirroring Profile Id (required)
        :type  port_mirroring_profile: :class:`com.vmware.nsx_policy.model_client.PortMirroringProfile`
        :param port_mirroring_profile: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch', {'port_mirroring_profile_id':
            port_mirroring_profile_id, 'port_mirroring_profile':
            port_mirroring_profile})

    def update(self, port_mirroring_profile_id, port_mirroring_profile):
        """
        Create or Replace port mirroring profile. Packets will be mirrored from
        source group, segment, port to destination group. Realized entities of
        this API can be found using the path of monitoring profile binding map
        that is used to apply this profile.

        :type  port_mirroring_profile_id: :class:`str`
        :param port_mirroring_profile_id: Port Mirroring Profiles Id (required)
        :type  port_mirroring_profile: :class:`com.vmware.nsx_policy.model_client.PortMirroringProfile`
        :param port_mirroring_profile: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.PortMirroringProfile`
        :return: com.vmware.nsx_policy.model.PortMirroringProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update', {'port_mirroring_profile_id':
            port_mirroring_profile_id, 'port_mirroring_profile':
            port_mirroring_profile})


class Segments(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.segments'
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _SegmentsStub)
        self._VAPI_OPERATION_IDS = {}

    def delete(self, segment_id):
        """
        Delete infra segment

        :type  segment_id: :class:`str`
        :param segment_id: Segment ID (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete', {'segment_id': segment_id})

    def delete_0(self, segment_id):
        """
        Force delete bypasses validations during segment deletion. This may
        result in an inconsistent connectivity.

        :type  segment_id: :class:`str`
        :param segment_id: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete_0', {'segment_id': segment_id})

    def get(self, segment_id):
        """
        Read infra segment

        :type  segment_id: :class:`str`
        :param segment_id: Segment ID (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.Segment`
        :return: com.vmware.nsx_policy.model.Segment
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'segment_id': segment_id})

    def list(self, cursor=None, include_mark_for_delete_objects=None,
        included_fields=None, page_size=None, sort_ascending=None, sort_by=None
        ):
        """
        Paginated list of all segments under infra.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.SegmentListResult`
        :return: com.vmware.nsx_policy.model.SegmentListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'cursor': cursor,
            'include_mark_for_delete_objects':
            include_mark_for_delete_objects, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})

    def patch(self, segment_id, segment):
        """
        If segment with the segment-id is not already present, create a new
        segment. If it already exists, update the segment with specified
        attributes.

        :type  segment_id: :class:`str`
        :param segment_id: Segment ID (required)
        :type  segment: :class:`com.vmware.nsx_policy.model_client.Segment`
        :param segment: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch', {'segment_id': segment_id, 'segment':
            segment})

    def update(self, segment_id, segment):
        """
        If segment with the segment-id is not already present, create a new
        segment. If it already exists, replace the segment with this object.

        :type  segment_id: :class:`str`
        :param segment_id: Segment ID (required)
        :type  segment: :class:`com.vmware.nsx_policy.model_client.Segment`
        :param segment: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.Segment`
        :return: com.vmware.nsx_policy.model.Segment
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update', {'segment_id': segment_id, 'segment':
            segment})


class Services(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.services'
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _ServicesStub)
        self._VAPI_OPERATION_IDS = {}

    def delete(self, service_id):
        """
        Delete Service

        :type  service_id: :class:`str`
        :param service_id: Service ID (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete', {'service_id': service_id})

    def get(self, service_id):
        """
        Read a service

        :type  service_id: :class:`str`
        :param service_id: Service ID (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.Service`
        :return: com.vmware.nsx_policy.model.Service
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'service_id': service_id})

    def list(self, cursor=None, default_service=None,
        include_mark_for_delete_objects=None, included_fields=None,
        page_size=None, sort_ascending=None, sort_by=None):
        """
        Paginated list of Services for infra.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  default_service: :class:`bool` or ``None``
        :param default_service: Fetch all default services (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.ServiceListResult`
        :return: com.vmware.nsx_policy.model.ServiceListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'cursor': cursor, 'default_service':
            default_service, 'include_mark_for_delete_objects':
            include_mark_for_delete_objects, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})

    def patch(self, service_id, service):
        """
        Create a new service if a service with the given ID does not already
        exist. Creates new service entries if populated in the service. If a
        service with the given ID already exists, patch the service including
        the nested service entries.

        :type  service_id: :class:`str`
        :param service_id: Service ID (required)
        :type  service: :class:`com.vmware.nsx_policy.model_client.Service`
        :param service: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch', {'service_id': service_id, 'service':
            service})

    def update(self, service_id, service):
        """
        Create a new service if a service with the given ID does not already
        exist. Creates new service entries if populated in the service. If a
        service with the given ID already exists, update the service including
        the nested service entries. This is a full replace.

        :type  service_id: :class:`str`
        :param service_id: Service ID (required)
        :type  service: :class:`com.vmware.nsx_policy.model_client.Service`
        :param service: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.Service`
        :return: com.vmware.nsx_policy.model.Service
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update', {'service_id': service_id, 'service':
            service})


class _DhcpRelayConfigsStub(ApiInterfaceStub):

    def __init__(self, config):
        delete_input_type = type.StructType('operation-input', {
            'dhcp_relay_config_id': type.StringType()})
        delete_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template=
            '/policy/api/v1/infra/dhcp-relay-configs/{dhcp-relay-config-id}',
            path_variables={'dhcp_relay_config_id': 'dhcp-relay-config-id'},
            query_parameters={}, content_type='application/json')
        get_input_type = type.StructType('operation-input', {
            'dhcp_relay_config_id': type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template=
            '/policy/api/v1/infra/dhcp-relay-configs/{dhcp-relay-config-id}',
            path_variables={'dhcp_relay_config_id': 'dhcp-relay-config-id'},
            query_parameters={}, content_type='application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/dhcp-relay-configs',
            path_variables={}, query_parameters={'cursor': 'cursor',
            'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        patch_input_type = type.StructType('operation-input', {
            'dhcp_relay_config_id': type.StringType(), 'dhcp_relay_config':
            type.ReferenceType('com.vmware.nsx_policy.model_client',
            'DhcpRelayConfig')})
        patch_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        patch_input_value_validator_list = [HasFieldsOfValidator()]
        patch_output_validator_list = []
        patch_rest_metadata = OperationRestMetadata(http_method='PATCH',
            url_template=
            '/policy/api/v1/infra/dhcp-relay-configs/{dhcp-relay-config-id}',
            request_body_parameter='dhcp_relay_config', path_variables={
            'dhcp_relay_config_id': 'dhcp-relay-config-id'},
            query_parameters={}, content_type='application/json')
        update_input_type = type.StructType('operation-input', {
            'dhcp_relay_config_id': type.StringType(), 'dhcp_relay_config':
            type.ReferenceType('com.vmware.nsx_policy.model_client',
            'DhcpRelayConfig')})
        update_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(http_method='PUT',
            url_template=
            '/policy/api/v1/infra/dhcp-relay-configs/{dhcp-relay-config-id}',
            request_body_parameter='dhcp_relay_config', path_variables={
            'dhcp_relay_config_id': 'dhcp-relay-config-id'},
            query_parameters={}, content_type='application/json')
        operations = {'delete': {'input_type': delete_input_type,
            'output_type': type.VoidType(), 'errors': delete_error_dict,
            'input_value_validator_list': delete_input_value_validator_list,
            'output_validator_list': delete_output_validator_list,
            'task_type': TaskType.NONE}, 'get': {'input_type':
            get_input_type, 'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'DhcpRelayConfig'),
            'errors': get_error_dict, 'input_value_validator_list':
            get_input_value_validator_list, 'output_validator_list':
            get_output_validator_list, 'task_type': TaskType.NONE}, 'list':
            {'input_type': list_input_type, 'output_type': type.
            ReferenceType('com.vmware.nsx_policy.model_client',
            'DhcpRelayConfigListResult'), 'errors': list_error_dict,
            'input_value_validator_list': list_input_value_validator_list,
            'output_validator_list': list_output_validator_list,
            'task_type': TaskType.NONE}, 'patch': {'input_type':
            patch_input_type, 'output_type': type.VoidType(), 'errors':
            patch_error_dict, 'input_value_validator_list':
            patch_input_value_validator_list, 'output_validator_list':
            patch_output_validator_list, 'task_type': TaskType.NONE},
            'update': {'input_type': update_input_type, 'output_type': type
            .ReferenceType('com.vmware.nsx_policy.model_client',
            'DhcpRelayConfig'), 'errors': update_error_dict,
            'input_value_validator_list': update_input_value_validator_list,
            'output_validator_list': update_output_validator_list,
            'task_type': TaskType.NONE}}
        rest_metadata = {'delete': delete_rest_metadata, 'get':
            get_rest_metadata, 'list': list_rest_metadata, 'patch':
            patch_rest_metadata, 'update': update_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.dhcp_relay_configs', config=config,
            operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)


class _DhcpServerConfigsStub(ApiInterfaceStub):

    def __init__(self, config):
        delete_input_type = type.StructType('operation-input', {
            'dhcp_server_config_id': type.StringType()})
        delete_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template=
            '/policy/api/v1/infra/dhcp-server-configs/{dhcp-server-config-id}',
            path_variables={'dhcp_server_config_id':
            'dhcp-server-config-id'}, query_parameters={}, content_type=
            'application/json')
        get_input_type = type.StructType('operation-input', {
            'dhcp_server_config_id': type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template=
            '/policy/api/v1/infra/dhcp-server-configs/{dhcp-server-config-id}',
            path_variables={'dhcp_server_config_id':
            'dhcp-server-config-id'}, query_parameters={}, content_type=
            'application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/dhcp-server-configs',
            path_variables={}, query_parameters={'cursor': 'cursor',
            'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        patch_input_type = type.StructType('operation-input', {
            'dhcp_server_config_id': type.StringType(),
            'dhcp_server_config': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'DhcpServerConfig')})
        patch_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        patch_input_value_validator_list = [HasFieldsOfValidator()]
        patch_output_validator_list = []
        patch_rest_metadata = OperationRestMetadata(http_method='PATCH',
            url_template=
            '/policy/api/v1/infra/dhcp-server-configs/{dhcp-server-config-id}',
            request_body_parameter='dhcp_server_config', path_variables={
            'dhcp_server_config_id': 'dhcp-server-config-id'},
            query_parameters={}, content_type='application/json')
        update_input_type = type.StructType('operation-input', {
            'dhcp_server_config_id': type.StringType(),
            'dhcp_server_config': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'DhcpServerConfig')})
        update_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(http_method='PUT',
            url_template=
            '/policy/api/v1/infra/dhcp-server-configs/{dhcp-server-config-id}',
            request_body_parameter='dhcp_server_config', path_variables={
            'dhcp_server_config_id': 'dhcp-server-config-id'},
            query_parameters={}, content_type='application/json')
        operations = {'delete': {'input_type': delete_input_type,
            'output_type': type.VoidType(), 'errors': delete_error_dict,
            'input_value_validator_list': delete_input_value_validator_list,
            'output_validator_list': delete_output_validator_list,
            'task_type': TaskType.NONE}, 'get': {'input_type':
            get_input_type, 'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'DhcpServerConfig'),
            'errors': get_error_dict, 'input_value_validator_list':
            get_input_value_validator_list, 'output_validator_list':
            get_output_validator_list, 'task_type': TaskType.NONE}, 'list':
            {'input_type': list_input_type, 'output_type': type.
            ReferenceType('com.vmware.nsx_policy.model_client',
            'DhcpServerConfigListResult'), 'errors': list_error_dict,
            'input_value_validator_list': list_input_value_validator_list,
            'output_validator_list': list_output_validator_list,
            'task_type': TaskType.NONE}, 'patch': {'input_type':
            patch_input_type, 'output_type': type.VoidType(), 'errors':
            patch_error_dict, 'input_value_validator_list':
            patch_input_value_validator_list, 'output_validator_list':
            patch_output_validator_list, 'task_type': TaskType.NONE},
            'update': {'input_type': update_input_type, 'output_type': type
            .ReferenceType('com.vmware.nsx_policy.model_client',
            'DhcpServerConfig'), 'errors': update_error_dict,
            'input_value_validator_list': update_input_value_validator_list,
            'output_validator_list': update_output_validator_list,
            'task_type': TaskType.NONE}}
        rest_metadata = {'delete': delete_rest_metadata, 'get':
            get_rest_metadata, 'list': list_rest_metadata, 'patch':
            patch_rest_metadata, 'update': update_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.dhcp_server_configs', config=
            config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)


class _DnsForwarderZonesStub(ApiInterfaceStub):

    def __init__(self, config):
        delete_input_type = type.StructType('operation-input', {
            'dns_forwarder_zone_id': type.StringType()})
        delete_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template=
            '/policy/api/v1/infra/dns-forwarder-zones/{dns-forwarder-zone-id}',
            path_variables={'dns_forwarder_zone_id':
            'dns-forwarder-zone-id'}, query_parameters={}, content_type=
            'application/json')
        get_input_type = type.StructType('operation-input', {
            'dns_forwarder_zone_id': type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template=
            '/policy/api/v1/infra/dns-forwarder-zones/{dns-forwarder-zone-id}',
            path_variables={'dns_forwarder_zone_id':
            'dns-forwarder-zone-id'}, query_parameters={}, content_type=
            'application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/dns-forwarder-zones',
            path_variables={}, query_parameters={'cursor': 'cursor',
            'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        patch_input_type = type.StructType('operation-input', {
            'dns_forwarder_zone_id': type.StringType(),
            'policy_dns_forwarder_zone': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'PolicyDnsForwarderZone')})
        patch_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        patch_input_value_validator_list = [HasFieldsOfValidator()]
        patch_output_validator_list = []
        patch_rest_metadata = OperationRestMetadata(http_method='PATCH',
            url_template=
            '/policy/api/v1/infra/dns-forwarder-zones/{dns-forwarder-zone-id}',
            request_body_parameter='policy_dns_forwarder_zone',
            path_variables={'dns_forwarder_zone_id':
            'dns-forwarder-zone-id'}, query_parameters={}, content_type=
            'application/json')
        update_input_type = type.StructType('operation-input', {
            'dns_forwarder_zone_id': type.StringType(),
            'policy_dns_forwarder_zone': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'PolicyDnsForwarderZone')})
        update_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(http_method='PUT',
            url_template=
            '/policy/api/v1/infra/dns-forwarder-zones/{dns-forwarder-zone-id}',
            request_body_parameter='policy_dns_forwarder_zone',
            path_variables={'dns_forwarder_zone_id':
            'dns-forwarder-zone-id'}, query_parameters={}, content_type=
            'application/json')
        operations = {'delete': {'input_type': delete_input_type,
            'output_type': type.VoidType(), 'errors': delete_error_dict,
            'input_value_validator_list': delete_input_value_validator_list,
            'output_validator_list': delete_output_validator_list,
            'task_type': TaskType.NONE}, 'get': {'input_type':
            get_input_type, 'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'PolicyDnsForwarderZone'),
            'errors': get_error_dict, 'input_value_validator_list':
            get_input_value_validator_list, 'output_validator_list':
            get_output_validator_list, 'task_type': TaskType.NONE}, 'list':
            {'input_type': list_input_type, 'output_type': type.
            ReferenceType('com.vmware.nsx_policy.model_client',
            'PolicyDnsForwarderZoneListResult'), 'errors': list_error_dict,
            'input_value_validator_list': list_input_value_validator_list,
            'output_validator_list': list_output_validator_list,
            'task_type': TaskType.NONE}, 'patch': {'input_type':
            patch_input_type, 'output_type': type.VoidType(), 'errors':
            patch_error_dict, 'input_value_validator_list':
            patch_input_value_validator_list, 'output_validator_list':
            patch_output_validator_list, 'task_type': TaskType.NONE},
            'update': {'input_type': update_input_type, 'output_type': type
            .ReferenceType('com.vmware.nsx_policy.model_client',
            'PolicyDnsForwarderZone'), 'errors': update_error_dict,
            'input_value_validator_list': update_input_value_validator_list,
            'output_validator_list': update_output_validator_list,
            'task_type': TaskType.NONE}}
        rest_metadata = {'delete': delete_rest_metadata, 'get':
            get_rest_metadata, 'list': list_rest_metadata, 'patch':
            patch_rest_metadata, 'update': update_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.dns_forwarder_zones', config=
            config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)


class _DomainsStub(ApiInterfaceStub):

    def __init__(self, config):
        get_input_type = type.StructType('operation-input', {'domain_id':
            type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/domains/{domain-id}',
            path_variables={'domain_id': 'domain-id'}, query_parameters={},
            content_type='application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/domains', path_variables={},
            query_parameters={'cursor': 'cursor',
            'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        operations = {'get': {'input_type': get_input_type, 'output_type':
            type.ReferenceType('com.vmware.nsx_policy.model_client',
            'Domain'), 'errors': get_error_dict,
            'input_value_validator_list': get_input_value_validator_list,
            'output_validator_list': get_output_validator_list, 'task_type':
            TaskType.NONE}, 'list': {'input_type': list_input_type,
            'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'DomainListResult'),
            'errors': list_error_dict, 'input_value_validator_list':
            list_input_value_validator_list, 'output_validator_list':
            list_output_validator_list, 'task_type': TaskType.NONE}}
        rest_metadata = {'get': get_rest_metadata, 'list': list_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.domains', config=config,
            operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)


class _DraftsStub(ApiInterfaceStub):

    def __init__(self, config):
        abort_input_type = type.StructType('operation-input', {'draft_id':
            type.StringType()})
        abort_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        abort_input_value_validator_list = []
        abort_output_validator_list = []
        abort_rest_metadata = OperationRestMetadata(http_method='POST',
            url_template=
            '/policy/api/v1/infra/drafts/{draft-id}?action=abort',
            path_variables={'draft_id': 'draft-id'}, query_parameters={},
            content_type='application/json')
        delete_input_type = type.StructType('operation-input', {'draft_id':
            type.StringType()})
        delete_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template='/policy/api/v1/infra/drafts/{draft-id}',
            path_variables={'draft_id': 'draft-id'}, query_parameters={},
            content_type='application/json')
        get_input_type = type.StructType('operation-input', {'draft_id':
            type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/drafts/{draft-id}',
            path_variables={'draft_id': 'draft-id'}, query_parameters={},
            content_type='application/json')
        list_input_type = type.StructType('operation-input', {'auto_drafts':
            type.OptionalType(type.BooleanType()), 'cursor': type.
            OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/drafts', path_variables={},
            query_parameters={'auto_drafts': 'auto_drafts', 'cursor':
            'cursor', 'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        patch_input_type = type.StructType('operation-input', {'draft_id':
            type.StringType(), 'policy_draft': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'PolicyDraft')})
        patch_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        patch_input_value_validator_list = [HasFieldsOfValidator()]
        patch_output_validator_list = []
        patch_rest_metadata = OperationRestMetadata(http_method='PATCH',
            url_template='/policy/api/v1/infra/drafts/{draft-id}',
            request_body_parameter='policy_draft', path_variables={
            'draft_id': 'draft-id'}, query_parameters={}, content_type=
            'application/json')
        publish_input_type = type.StructType('operation-input', {'draft_id':
            type.StringType(), 'infra': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'Infra')})
        publish_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        publish_input_value_validator_list = [HasFieldsOfValidator()]
        publish_output_validator_list = []
        publish_rest_metadata = OperationRestMetadata(http_method='POST',
            url_template=
            '/policy/api/v1/infra/drafts/{draft-id}?action=publish',
            request_body_parameter='infra', path_variables={'draft_id':
            'draft-id'}, query_parameters={}, content_type='application/json')
        update_input_type = type.StructType('operation-input', {'draft_id':
            type.StringType(), 'policy_draft': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'PolicyDraft')})
        update_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(http_method='PUT',
            url_template='/policy/api/v1/infra/drafts/{draft-id}',
            request_body_parameter='policy_draft', path_variables={
            'draft_id': 'draft-id'}, query_parameters={}, content_type=
            'application/json')
        operations = {'abort': {'input_type': abort_input_type,
            'output_type': type.VoidType(), 'errors': abort_error_dict,
            'input_value_validator_list': abort_input_value_validator_list,
            'output_validator_list': abort_output_validator_list,
            'task_type': TaskType.NONE}, 'delete': {'input_type':
            delete_input_type, 'output_type': type.VoidType(), 'errors':
            delete_error_dict, 'input_value_validator_list':
            delete_input_value_validator_list, 'output_validator_list':
            delete_output_validator_list, 'task_type': TaskType.NONE},
            'get': {'input_type': get_input_type, 'output_type': type.
            ReferenceType('com.vmware.nsx_policy.model_client',
            'PolicyDraft'), 'errors': get_error_dict,
            'input_value_validator_list': get_input_value_validator_list,
            'output_validator_list': get_output_validator_list, 'task_type':
            TaskType.NONE}, 'list': {'input_type': list_input_type,
            'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'PolicyDraftListResult'),
            'errors': list_error_dict, 'input_value_validator_list':
            list_input_value_validator_list, 'output_validator_list':
            list_output_validator_list, 'task_type': TaskType.NONE},
            'patch': {'input_type': patch_input_type, 'output_type': type.
            VoidType(), 'errors': patch_error_dict,
            'input_value_validator_list': patch_input_value_validator_list,
            'output_validator_list': patch_output_validator_list,
            'task_type': TaskType.NONE}, 'publish': {'input_type':
            publish_input_type, 'output_type': type.VoidType(), 'errors':
            publish_error_dict, 'input_value_validator_list':
            publish_input_value_validator_list, 'output_validator_list':
            publish_output_validator_list, 'task_type': TaskType.NONE},
            'update': {'input_type': update_input_type, 'output_type': type
            .ReferenceType('com.vmware.nsx_policy.model_client',
            'PolicyDraft'), 'errors': update_error_dict,
            'input_value_validator_list': update_input_value_validator_list,
            'output_validator_list': update_output_validator_list,
            'task_type': TaskType.NONE}}
        rest_metadata = {'abort': abort_rest_metadata, 'delete':
            delete_rest_metadata, 'get': get_rest_metadata, 'list':
            list_rest_metadata, 'patch': patch_rest_metadata, 'publish':
            publish_rest_metadata, 'update': update_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.drafts', config=config, operations
            =operations, rest_metadata=rest_metadata, is_vapi_rest=False)


class _GroupAssociationsStub(ApiInterfaceStub):

    def __init__(self, config):
        list_input_type = type.StructType('operation-input', {'intent_path':
            type.StringType(), 'cursor': type.OptionalType(type.StringType(
            )), 'enforcement_point_path': type.OptionalType(type.StringType
            ()), 'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = []
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/group-associations',
            path_variables={}, query_parameters={'intent_path':
            'intent_path', 'cursor': 'cursor', 'enforcement_point_path':
            'enforcement_point_path', 'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        operations = {'list': {'input_type': list_input_type, 'output_type':
            type.ReferenceType('com.vmware.nsx_policy.model_client',
            'PolicyResourceReferenceForEPListResult'), 'errors':
            list_error_dict, 'input_value_validator_list':
            list_input_value_validator_list, 'output_validator_list':
            list_output_validator_list, 'task_type': TaskType.NONE}}
        rest_metadata = {'list': list_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.group_associations', config=config,
            operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)


class _IpfixCollectorProfilesStub(ApiInterfaceStub):

    def __init__(self, config):
        delete_input_type = type.StructType('operation-input', {
            'ipfix_collector_profile_id': type.StringType()})
        delete_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template=
            '/policy/api/v1/infra/ipfix-collector-profiles/{ipfix-collector-profile-id}'
            , path_variables={'ipfix_collector_profile_id':
            'ipfix-collector-profile-id'}, query_parameters={},
            content_type='application/json')
        get_input_type = type.StructType('operation-input', {
            'ipfix_collector_profile_id': type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template=
            '/policy/api/v1/infra/ipfix-collector-profiles/{ipfix-collector-profile-id}'
            , path_variables={'ipfix_collector_profile_id':
            'ipfix-collector-profile-id'}, query_parameters={},
            content_type='application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/ipfix-collector-profiles',
            path_variables={}, query_parameters={'cursor': 'cursor',
            'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        patch_input_type = type.StructType('operation-input', {
            'ipfix_collector_profile_id': type.StringType(),
            'i_PFIX_collector_profile': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'IPFIXCollectorProfile')})
        patch_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        patch_input_value_validator_list = [HasFieldsOfValidator()]
        patch_output_validator_list = []
        patch_rest_metadata = OperationRestMetadata(http_method='PATCH',
            url_template=
            '/policy/api/v1/infra/ipfix-collector-profiles/{ipfix-collector-profile-id}'
            , request_body_parameter='i_PFIX_collector_profile',
            path_variables={'ipfix_collector_profile_id':
            'ipfix-collector-profile-id'}, query_parameters={},
            content_type='application/json')
        update_input_type = type.StructType('operation-input', {
            'ipfix_collector_profile_id': type.StringType(),
            'i_PFIX_collector_profile': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'IPFIXCollectorProfile')})
        update_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(http_method='PUT',
            url_template=
            '/policy/api/v1/infra/ipfix-collector-profiles/{ipfix-collector-profile-id}'
            , request_body_parameter='i_PFIX_collector_profile',
            path_variables={'ipfix_collector_profile_id':
            'ipfix-collector-profile-id'}, query_parameters={},
            content_type='application/json')
        operations = {'delete': {'input_type': delete_input_type,
            'output_type': type.VoidType(), 'errors': delete_error_dict,
            'input_value_validator_list': delete_input_value_validator_list,
            'output_validator_list': delete_output_validator_list,
            'task_type': TaskType.NONE}, 'get': {'input_type':
            get_input_type, 'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'IPFIXCollectorProfile'),
            'errors': get_error_dict, 'input_value_validator_list':
            get_input_value_validator_list, 'output_validator_list':
            get_output_validator_list, 'task_type': TaskType.NONE}, 'list':
            {'input_type': list_input_type, 'output_type': type.
            ReferenceType('com.vmware.nsx_policy.model_client',
            'IPFIXCollectorProfileListResult'), 'errors': list_error_dict,
            'input_value_validator_list': list_input_value_validator_list,
            'output_validator_list': list_output_validator_list,
            'task_type': TaskType.NONE}, 'patch': {'input_type':
            patch_input_type, 'output_type': type.VoidType(), 'errors':
            patch_error_dict, 'input_value_validator_list':
            patch_input_value_validator_list, 'output_validator_list':
            patch_output_validator_list, 'task_type': TaskType.NONE},
            'update': {'input_type': update_input_type, 'output_type': type
            .ReferenceType('com.vmware.nsx_policy.model_client',
            'IPFIXCollectorProfile'), 'errors': update_error_dict,
            'input_value_validator_list': update_input_value_validator_list,
            'output_validator_list': update_output_validator_list,
            'task_type': TaskType.NONE}}
        rest_metadata = {'delete': delete_rest_metadata, 'get':
            get_rest_metadata, 'list': list_rest_metadata, 'patch':
            patch_rest_metadata, 'update': update_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.ipfix_collector_profiles', config=
            config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)


class _IpfixDfwCollectorProfilesStub(ApiInterfaceStub):

    def __init__(self, config):
        delete_input_type = type.StructType('operation-input', {
            'ipfix_dfw_collector_profile_id': type.StringType()})
        delete_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template=
            '/policy/api/v1/infra/ipfix-dfw-collector-profiles/{ipfix-dfw-collector-profile-id}'
            , path_variables={'ipfix_dfw_collector_profile_id':
            'ipfix-dfw-collector-profile-id'}, query_parameters={},
            content_type='application/json')
        get_input_type = type.StructType('operation-input', {
            'ipfix_dfw_collector_profile_id': type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template=
            '/policy/api/v1/infra/ipfix-dfw-collector-profiles/{ipfix-dfw-collector-profile-id}'
            , path_variables={'ipfix_dfw_collector_profile_id':
            'ipfix-dfw-collector-profile-id'}, query_parameters={},
            content_type='application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template=
            '/policy/api/v1/infra/ipfix-dfw-collector-profiles',
            path_variables={}, query_parameters={'cursor': 'cursor',
            'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        patch_input_type = type.StructType('operation-input', {
            'ipfix_dfw_collector_profile_id': type.StringType(),
            'i_PFIXDFW_collector_profile': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'IPFIXDFWCollectorProfile')})
        patch_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        patch_input_value_validator_list = [HasFieldsOfValidator()]
        patch_output_validator_list = []
        patch_rest_metadata = OperationRestMetadata(http_method='PATCH',
            url_template=
            '/policy/api/v1/infra/ipfix-dfw-collector-profiles/{ipfix-dfw-collector-profile-id}'
            , request_body_parameter='i_PFIXDFW_collector_profile',
            path_variables={'ipfix_dfw_collector_profile_id':
            'ipfix-dfw-collector-profile-id'}, query_parameters={},
            content_type='application/json')
        update_input_type = type.StructType('operation-input', {
            'ipfix_dfw_collector_profile_id': type.StringType(),
            'i_PFIXDFW_collector_profile': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'IPFIXDFWCollectorProfile')})
        update_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(http_method='PUT',
            url_template=
            '/policy/api/v1/infra/ipfix-dfw-collector-profiles/{ipfix-dfw-collector-profile-id}'
            , request_body_parameter='i_PFIXDFW_collector_profile',
            path_variables={'ipfix_dfw_collector_profile_id':
            'ipfix-dfw-collector-profile-id'}, query_parameters={},
            content_type='application/json')
        operations = {'delete': {'input_type': delete_input_type,
            'output_type': type.VoidType(), 'errors': delete_error_dict,
            'input_value_validator_list': delete_input_value_validator_list,
            'output_validator_list': delete_output_validator_list,
            'task_type': TaskType.NONE}, 'get': {'input_type':
            get_input_type, 'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client',
            'IPFIXDFWCollectorProfile'), 'errors': get_error_dict,
            'input_value_validator_list': get_input_value_validator_list,
            'output_validator_list': get_output_validator_list, 'task_type':
            TaskType.NONE}, 'list': {'input_type': list_input_type,
            'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client',
            'IPFIXDFWCollectorProfileListResult'), 'errors':
            list_error_dict, 'input_value_validator_list':
            list_input_value_validator_list, 'output_validator_list':
            list_output_validator_list, 'task_type': TaskType.NONE},
            'patch': {'input_type': patch_input_type, 'output_type': type.
            VoidType(), 'errors': patch_error_dict,
            'input_value_validator_list': patch_input_value_validator_list,
            'output_validator_list': patch_output_validator_list,
            'task_type': TaskType.NONE}, 'update': {'input_type':
            update_input_type, 'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client',
            'IPFIXDFWCollectorProfile'), 'errors': update_error_dict,
            'input_value_validator_list': update_input_value_validator_list,
            'output_validator_list': update_output_validator_list,
            'task_type': TaskType.NONE}}
        rest_metadata = {'delete': delete_rest_metadata, 'get':
            get_rest_metadata, 'list': list_rest_metadata, 'patch':
            patch_rest_metadata, 'update': update_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.ipfix_dfw_collector_profiles',
            config=config, operations=operations, rest_metadata=
            rest_metadata, is_vapi_rest=False)


class _IpfixDfwProfilesStub(ApiInterfaceStub):

    def __init__(self, config):
        delete_input_type = type.StructType('operation-input', {
            'ipfix_dfw_profile_id': type.StringType()})
        delete_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template=
            '/policy/api/v1/infra/ipfix-dfw-profiles/{ipfix-dfw-profile-id}',
            path_variables={'ipfix_dfw_profile_id': 'ipfix-dfw-profile-id'},
            query_parameters={}, content_type='application/json')
        get_input_type = type.StructType('operation-input', {
            'ipfix_dfw_profile_id': type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template=
            '/policy/api/v1/infra/ipfix-dfw-profiles/{ipfix-dfw-profile-id}',
            path_variables={'ipfix_dfw_profile_id': 'ipfix-dfw-profile-id'},
            query_parameters={}, content_type='application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/ipfix-dfw-profiles',
            path_variables={}, query_parameters={'cursor': 'cursor',
            'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        patch_input_type = type.StructType('operation-input', {
            'ipfix_dfw_profile_id': type.StringType(), 'i_PFIXDFW_profile':
            type.ReferenceType('com.vmware.nsx_policy.model_client',
            'IPFIXDFWProfile')})
        patch_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        patch_input_value_validator_list = [HasFieldsOfValidator()]
        patch_output_validator_list = []
        patch_rest_metadata = OperationRestMetadata(http_method='PATCH',
            url_template=
            '/policy/api/v1/infra/ipfix-dfw-profiles/{ipfix-dfw-profile-id}',
            request_body_parameter='i_PFIXDFW_profile', path_variables={
            'ipfix_dfw_profile_id': 'ipfix-dfw-profile-id'},
            query_parameters={}, content_type='application/json')
        update_input_type = type.StructType('operation-input', {
            'ipfix_dfw_profile_id': type.StringType(), 'i_PFIXDFW_profile':
            type.ReferenceType('com.vmware.nsx_policy.model_client',
            'IPFIXDFWProfile')})
        update_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(http_method='PUT',
            url_template=
            '/policy/api/v1/infra/ipfix-dfw-profiles/{ipfix-dfw-profile-id}',
            request_body_parameter='i_PFIXDFW_profile', path_variables={
            'ipfix_dfw_profile_id': 'ipfix-dfw-profile-id'},
            query_parameters={}, content_type='application/json')
        operations = {'delete': {'input_type': delete_input_type,
            'output_type': type.VoidType(), 'errors': delete_error_dict,
            'input_value_validator_list': delete_input_value_validator_list,
            'output_validator_list': delete_output_validator_list,
            'task_type': TaskType.NONE}, 'get': {'input_type':
            get_input_type, 'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'IPFIXDFWProfile'),
            'errors': get_error_dict, 'input_value_validator_list':
            get_input_value_validator_list, 'output_validator_list':
            get_output_validator_list, 'task_type': TaskType.NONE}, 'list':
            {'input_type': list_input_type, 'output_type': type.
            ReferenceType('com.vmware.nsx_policy.model_client',
            'IPFIXDFWProfileListResult'), 'errors': list_error_dict,
            'input_value_validator_list': list_input_value_validator_list,
            'output_validator_list': list_output_validator_list,
            'task_type': TaskType.NONE}, 'patch': {'input_type':
            patch_input_type, 'output_type': type.VoidType(), 'errors':
            patch_error_dict, 'input_value_validator_list':
            patch_input_value_validator_list, 'output_validator_list':
            patch_output_validator_list, 'task_type': TaskType.NONE},
            'update': {'input_type': update_input_type, 'output_type': type
            .ReferenceType('com.vmware.nsx_policy.model_client',
            'IPFIXDFWProfile'), 'errors': update_error_dict,
            'input_value_validator_list': update_input_value_validator_list,
            'output_validator_list': update_output_validator_list,
            'task_type': TaskType.NONE}}
        rest_metadata = {'delete': delete_rest_metadata, 'get':
            get_rest_metadata, 'list': list_rest_metadata, 'patch':
            patch_rest_metadata, 'update': update_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.ipfix_dfw_profiles', config=config,
            operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)


class _IpfixL2CollectorProfilesStub(ApiInterfaceStub):

    def __init__(self, config):
        delete_input_type = type.StructType('operation-input', {
            'ipfix_l2_collector_profile_id': type.StringType()})
        delete_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template=
            '/policy/api/v1/infra/ipfix-l2-collector-profiles/{ipfix-l2-collector-profile-id}'
            , path_variables={'ipfix_l2_collector_profile_id':
            'ipfix-l2-collector-profile-id'}, query_parameters={},
            content_type='application/json')
        get_input_type = type.StructType('operation-input', {
            'ipfix_l2_collector_profile_id': type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template=
            '/policy/api/v1/infra/ipfix-l2-collector-profiles/{ipfix-l2-collector-profile-id}'
            , path_variables={'ipfix_l2_collector_profile_id':
            'ipfix-l2-collector-profile-id'}, query_parameters={},
            content_type='application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/ipfix-l2-collector-profiles',
            path_variables={}, query_parameters={'cursor': 'cursor',
            'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        patch_input_type = type.StructType('operation-input', {
            'ipfix_l2_collector_profile_id': type.StringType(),
            'i_PFIX_l2_collector_profile': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'IPFIXL2CollectorProfile')})
        patch_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        patch_input_value_validator_list = [HasFieldsOfValidator()]
        patch_output_validator_list = []
        patch_rest_metadata = OperationRestMetadata(http_method='PATCH',
            url_template=
            '/policy/api/v1/infra/ipfix-l2-collector-profiles/{ipfix-l2-collector-profile-id}'
            , request_body_parameter='i_PFIX_l2_collector_profile',
            path_variables={'ipfix_l2_collector_profile_id':
            'ipfix-l2-collector-profile-id'}, query_parameters={},
            content_type='application/json')
        update_input_type = type.StructType('operation-input', {
            'ipfix_l2_collector_profile_id': type.StringType(),
            'i_PFIX_l2_collector_profile': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'IPFIXL2CollectorProfile')})
        update_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(http_method='PUT',
            url_template=
            '/policy/api/v1/infra/ipfix-l2-collector-profiles/{ipfix-l2-collector-profile-id}'
            , request_body_parameter='i_PFIX_l2_collector_profile',
            path_variables={'ipfix_l2_collector_profile_id':
            'ipfix-l2-collector-profile-id'}, query_parameters={},
            content_type='application/json')
        operations = {'delete': {'input_type': delete_input_type,
            'output_type': type.VoidType(), 'errors': delete_error_dict,
            'input_value_validator_list': delete_input_value_validator_list,
            'output_validator_list': delete_output_validator_list,
            'task_type': TaskType.NONE}, 'get': {'input_type':
            get_input_type, 'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'IPFIXL2CollectorProfile'
            ), 'errors': get_error_dict, 'input_value_validator_list':
            get_input_value_validator_list, 'output_validator_list':
            get_output_validator_list, 'task_type': TaskType.NONE}, 'list':
            {'input_type': list_input_type, 'output_type': type.
            ReferenceType('com.vmware.nsx_policy.model_client',
            'IPFIXL2CollectorProfileListResult'), 'errors': list_error_dict,
            'input_value_validator_list': list_input_value_validator_list,
            'output_validator_list': list_output_validator_list,
            'task_type': TaskType.NONE}, 'patch': {'input_type':
            patch_input_type, 'output_type': type.VoidType(), 'errors':
            patch_error_dict, 'input_value_validator_list':
            patch_input_value_validator_list, 'output_validator_list':
            patch_output_validator_list, 'task_type': TaskType.NONE},
            'update': {'input_type': update_input_type, 'output_type': type
            .ReferenceType('com.vmware.nsx_policy.model_client',
            'IPFIXL2CollectorProfile'), 'errors': update_error_dict,
            'input_value_validator_list': update_input_value_validator_list,
            'output_validator_list': update_output_validator_list,
            'task_type': TaskType.NONE}}
        rest_metadata = {'delete': delete_rest_metadata, 'get':
            get_rest_metadata, 'list': list_rest_metadata, 'patch':
            patch_rest_metadata, 'update': update_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.ipfix_l2_collector_profiles',
            config=config, operations=operations, rest_metadata=
            rest_metadata, is_vapi_rest=False)


class _IpfixL2ProfilesStub(ApiInterfaceStub):

    def __init__(self, config):
        delete_input_type = type.StructType('operation-input', {
            'ipfix_l2_profile_id': type.StringType()})
        delete_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template=
            '/policy/api/v1/infra/ipfix-l2-profiles/{ipfix-l2-profile-id}',
            path_variables={'ipfix_l2_profile_id': 'ipfix-l2-profile-id'},
            query_parameters={}, content_type='application/json')
        get_input_type = type.StructType('operation-input', {
            'ipfix_l2_profile_id': type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template=
            '/policy/api/v1/infra/ipfix-l2-profiles/{ipfix-l2-profile-id}',
            path_variables={'ipfix_l2_profile_id': 'ipfix-l2-profile-id'},
            query_parameters={}, content_type='application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/ipfix-l2-profiles',
            path_variables={}, query_parameters={'cursor': 'cursor',
            'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        patch_input_type = type.StructType('operation-input', {
            'ipfix_l2_profile_id': type.StringType(), 'i_PFIX_l2_profile':
            type.ReferenceType('com.vmware.nsx_policy.model_client',
            'IPFIXL2Profile')})
        patch_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        patch_input_value_validator_list = [HasFieldsOfValidator()]
        patch_output_validator_list = []
        patch_rest_metadata = OperationRestMetadata(http_method='PATCH',
            url_template=
            '/policy/api/v1/infra/ipfix-l2-profiles/{ipfix-l2-profile-id}',
            request_body_parameter='i_PFIX_l2_profile', path_variables={
            'ipfix_l2_profile_id': 'ipfix-l2-profile-id'}, query_parameters
            ={}, content_type='application/json')
        update_input_type = type.StructType('operation-input', {
            'ipfix_l2_profile_id': type.StringType(), 'i_PFIX_l2_profile':
            type.ReferenceType('com.vmware.nsx_policy.model_client',
            'IPFIXL2Profile')})
        update_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(http_method='PUT',
            url_template=
            '/policy/api/v1/infra/ipfix-l2-profiles/{ipfix-l2-profile-id}',
            request_body_parameter='i_PFIX_l2_profile', path_variables={
            'ipfix_l2_profile_id': 'ipfix-l2-profile-id'}, query_parameters
            ={}, content_type='application/json')
        operations = {'delete': {'input_type': delete_input_type,
            'output_type': type.VoidType(), 'errors': delete_error_dict,
            'input_value_validator_list': delete_input_value_validator_list,
            'output_validator_list': delete_output_validator_list,
            'task_type': TaskType.NONE}, 'get': {'input_type':
            get_input_type, 'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'IPFIXL2Profile'),
            'errors': get_error_dict, 'input_value_validator_list':
            get_input_value_validator_list, 'output_validator_list':
            get_output_validator_list, 'task_type': TaskType.NONE}, 'list':
            {'input_type': list_input_type, 'output_type': type.
            ReferenceType('com.vmware.nsx_policy.model_client',
            'IPFIXL2ProfileListResult'), 'errors': list_error_dict,
            'input_value_validator_list': list_input_value_validator_list,
            'output_validator_list': list_output_validator_list,
            'task_type': TaskType.NONE}, 'patch': {'input_type':
            patch_input_type, 'output_type': type.VoidType(), 'errors':
            patch_error_dict, 'input_value_validator_list':
            patch_input_value_validator_list, 'output_validator_list':
            patch_output_validator_list, 'task_type': TaskType.NONE},
            'update': {'input_type': update_input_type, 'output_type': type
            .ReferenceType('com.vmware.nsx_policy.model_client',
            'IPFIXL2Profile'), 'errors': update_error_dict,
            'input_value_validator_list': update_input_value_validator_list,
            'output_validator_list': update_output_validator_list,
            'task_type': TaskType.NONE}}
        rest_metadata = {'delete': delete_rest_metadata, 'get':
            get_rest_metadata, 'list': list_rest_metadata, 'patch':
            patch_rest_metadata, 'update': update_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.ipfix_l2_profiles', config=config,
            operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)


class _IpsecVpnDpdProfilesStub(ApiInterfaceStub):

    def __init__(self, config):
        delete_input_type = type.StructType('operation-input', {
            'dpd_profile_id': type.StringType()})
        delete_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template=
            '/policy/api/v1/infra/ipsec-vpn-dpd-profiles/{dpd-profile-id}',
            path_variables={'dpd_profile_id': 'dpd-profile-id'},
            query_parameters={}, content_type='application/json')
        get_input_type = type.StructType('operation-input', {
            'dpd_profile_id': type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template=
            '/policy/api/v1/infra/ipsec-vpn-dpd-profiles/{dpd-profile-id}',
            path_variables={'dpd_profile_id': 'dpd-profile-id'},
            query_parameters={}, content_type='application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/ipsec-vpn-dpd-profiles',
            path_variables={}, query_parameters={'cursor': 'cursor',
            'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        patch_input_type = type.StructType('operation-input', {
            'dpd_profile_id': type.StringType(), 'ip_sec_vpn_dpd_profile':
            type.ReferenceType('com.vmware.nsx_policy.model_client',
            'IPSecVpnDpdProfile')})
        patch_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        patch_input_value_validator_list = [HasFieldsOfValidator()]
        patch_output_validator_list = []
        patch_rest_metadata = OperationRestMetadata(http_method='PATCH',
            url_template=
            '/policy/api/v1/infra/ipsec-vpn-dpd-profiles/{dpd-profile-id}',
            request_body_parameter='ip_sec_vpn_dpd_profile', path_variables
            ={'dpd_profile_id': 'dpd-profile-id'}, query_parameters={},
            content_type='application/json')
        update_input_type = type.StructType('operation-input', {
            'dpd_profile_id': type.StringType(), 'ip_sec_vpn_dpd_profile':
            type.ReferenceType('com.vmware.nsx_policy.model_client',
            'IPSecVpnDpdProfile')})
        update_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(http_method='PUT',
            url_template=
            '/policy/api/v1/infra/ipsec-vpn-dpd-profiles/{dpd-profile-id}',
            request_body_parameter='ip_sec_vpn_dpd_profile', path_variables
            ={'dpd_profile_id': 'dpd-profile-id'}, query_parameters={},
            content_type='application/json')
        operations = {'delete': {'input_type': delete_input_type,
            'output_type': type.VoidType(), 'errors': delete_error_dict,
            'input_value_validator_list': delete_input_value_validator_list,
            'output_validator_list': delete_output_validator_list,
            'task_type': TaskType.NONE}, 'get': {'input_type':
            get_input_type, 'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'IPSecVpnDpdProfile'),
            'errors': get_error_dict, 'input_value_validator_list':
            get_input_value_validator_list, 'output_validator_list':
            get_output_validator_list, 'task_type': TaskType.NONE}, 'list':
            {'input_type': list_input_type, 'output_type': type.
            ReferenceType('com.vmware.nsx_policy.model_client',
            'IPSecVpnDpdProfileListResult'), 'errors': list_error_dict,
            'input_value_validator_list': list_input_value_validator_list,
            'output_validator_list': list_output_validator_list,
            'task_type': TaskType.NONE}, 'patch': {'input_type':
            patch_input_type, 'output_type': type.VoidType(), 'errors':
            patch_error_dict, 'input_value_validator_list':
            patch_input_value_validator_list, 'output_validator_list':
            patch_output_validator_list, 'task_type': TaskType.NONE},
            'update': {'input_type': update_input_type, 'output_type': type
            .ReferenceType('com.vmware.nsx_policy.model_client',
            'IPSecVpnDpdProfile'), 'errors': update_error_dict,
            'input_value_validator_list': update_input_value_validator_list,
            'output_validator_list': update_output_validator_list,
            'task_type': TaskType.NONE}}
        rest_metadata = {'delete': delete_rest_metadata, 'get':
            get_rest_metadata, 'list': list_rest_metadata, 'patch':
            patch_rest_metadata, 'update': update_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.ipsec_vpn_dpd_profiles', config=
            config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)


class _IpsecVpnIkeProfilesStub(ApiInterfaceStub):

    def __init__(self, config):
        delete_input_type = type.StructType('operation-input', {
            'ike_profile_id': type.StringType()})
        delete_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template=
            '/policy/api/v1/infra/ipsec-vpn-ike-profiles/{ike-profile-id}',
            path_variables={'ike_profile_id': 'ike-profile-id'},
            query_parameters={}, content_type='application/json')
        get_input_type = type.StructType('operation-input', {
            'ike_profile_id': type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template=
            '/policy/api/v1/infra/ipsec-vpn-ike-profiles/{ike-profile-id}',
            path_variables={'ike_profile_id': 'ike-profile-id'},
            query_parameters={}, content_type='application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/ipsec-vpn-ike-profiles',
            path_variables={}, query_parameters={'cursor': 'cursor',
            'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        patch_input_type = type.StructType('operation-input', {
            'ike_profile_id': type.StringType(), 'ip_sec_vpn_ike_profile':
            type.ReferenceType('com.vmware.nsx_policy.model_client',
            'IPSecVpnIkeProfile')})
        patch_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        patch_input_value_validator_list = [HasFieldsOfValidator()]
        patch_output_validator_list = []
        patch_rest_metadata = OperationRestMetadata(http_method='PATCH',
            url_template=
            '/policy/api/v1/infra/ipsec-vpn-ike-profiles/{ike-profile-id}',
            request_body_parameter='ip_sec_vpn_ike_profile', path_variables
            ={'ike_profile_id': 'ike-profile-id'}, query_parameters={},
            content_type='application/json')
        update_input_type = type.StructType('operation-input', {
            'ike_profile_id': type.StringType(), 'ip_sec_vpn_ike_profile':
            type.ReferenceType('com.vmware.nsx_policy.model_client',
            'IPSecVpnIkeProfile')})
        update_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(http_method='PUT',
            url_template=
            '/policy/api/v1/infra/ipsec-vpn-ike-profiles/{ike-profile-id}',
            request_body_parameter='ip_sec_vpn_ike_profile', path_variables
            ={'ike_profile_id': 'ike-profile-id'}, query_parameters={},
            content_type='application/json')
        operations = {'delete': {'input_type': delete_input_type,
            'output_type': type.VoidType(), 'errors': delete_error_dict,
            'input_value_validator_list': delete_input_value_validator_list,
            'output_validator_list': delete_output_validator_list,
            'task_type': TaskType.NONE}, 'get': {'input_type':
            get_input_type, 'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'IPSecVpnIkeProfile'),
            'errors': get_error_dict, 'input_value_validator_list':
            get_input_value_validator_list, 'output_validator_list':
            get_output_validator_list, 'task_type': TaskType.NONE}, 'list':
            {'input_type': list_input_type, 'output_type': type.
            ReferenceType('com.vmware.nsx_policy.model_client',
            'IPSecVpnIkeProfileListResult'), 'errors': list_error_dict,
            'input_value_validator_list': list_input_value_validator_list,
            'output_validator_list': list_output_validator_list,
            'task_type': TaskType.NONE}, 'patch': {'input_type':
            patch_input_type, 'output_type': type.VoidType(), 'errors':
            patch_error_dict, 'input_value_validator_list':
            patch_input_value_validator_list, 'output_validator_list':
            patch_output_validator_list, 'task_type': TaskType.NONE},
            'update': {'input_type': update_input_type, 'output_type': type
            .ReferenceType('com.vmware.nsx_policy.model_client',
            'IPSecVpnIkeProfile'), 'errors': update_error_dict,
            'input_value_validator_list': update_input_value_validator_list,
            'output_validator_list': update_output_validator_list,
            'task_type': TaskType.NONE}}
        rest_metadata = {'delete': delete_rest_metadata, 'get':
            get_rest_metadata, 'list': list_rest_metadata, 'patch':
            patch_rest_metadata, 'update': update_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.ipsec_vpn_ike_profiles', config=
            config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)


class _IpsecVpnTunnelProfilesStub(ApiInterfaceStub):

    def __init__(self, config):
        delete_input_type = type.StructType('operation-input', {
            'tunnel_profile_id': type.StringType()})
        delete_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template=
            '/policy/api/v1/infra/ipsec-vpn-tunnel-profiles/{tunnel-profile-id}'
            , path_variables={'tunnel_profile_id': 'tunnel-profile-id'},
            query_parameters={}, content_type='application/json')
        get_input_type = type.StructType('operation-input', {
            'tunnel_profile_id': type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template=
            '/policy/api/v1/infra/ipsec-vpn-tunnel-profiles/{tunnel-profile-id}'
            , path_variables={'tunnel_profile_id': 'tunnel-profile-id'},
            query_parameters={}, content_type='application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/ipsec-vpn-tunnel-profiles',
            path_variables={}, query_parameters={'cursor': 'cursor',
            'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        patch_input_type = type.StructType('operation-input', {
            'tunnel_profile_id': type.StringType(),
            'ip_sec_vpn_tunnel_profile': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'IPSecVpnTunnelProfile')})
        patch_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        patch_input_value_validator_list = [HasFieldsOfValidator()]
        patch_output_validator_list = []
        patch_rest_metadata = OperationRestMetadata(http_method='PATCH',
            url_template=
            '/policy/api/v1/infra/ipsec-vpn-tunnel-profiles/{tunnel-profile-id}'
            , request_body_parameter='ip_sec_vpn_tunnel_profile',
            path_variables={'tunnel_profile_id': 'tunnel-profile-id'},
            query_parameters={}, content_type='application/json')
        update_input_type = type.StructType('operation-input', {
            'tunnel_profile_id': type.StringType(),
            'ip_sec_vpn_tunnel_profile': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'IPSecVpnTunnelProfile')})
        update_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(http_method='PUT',
            url_template=
            '/policy/api/v1/infra/ipsec-vpn-tunnel-profiles/{tunnel-profile-id}'
            , request_body_parameter='ip_sec_vpn_tunnel_profile',
            path_variables={'tunnel_profile_id': 'tunnel-profile-id'},
            query_parameters={}, content_type='application/json')
        operations = {'delete': {'input_type': delete_input_type,
            'output_type': type.VoidType(), 'errors': delete_error_dict,
            'input_value_validator_list': delete_input_value_validator_list,
            'output_validator_list': delete_output_validator_list,
            'task_type': TaskType.NONE}, 'get': {'input_type':
            get_input_type, 'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'IPSecVpnTunnelProfile'),
            'errors': get_error_dict, 'input_value_validator_list':
            get_input_value_validator_list, 'output_validator_list':
            get_output_validator_list, 'task_type': TaskType.NONE}, 'list':
            {'input_type': list_input_type, 'output_type': type.
            ReferenceType('com.vmware.nsx_policy.model_client',
            'IPSecVpnTunnelProfileListResult'), 'errors': list_error_dict,
            'input_value_validator_list': list_input_value_validator_list,
            'output_validator_list': list_output_validator_list,
            'task_type': TaskType.NONE}, 'patch': {'input_type':
            patch_input_type, 'output_type': type.VoidType(), 'errors':
            patch_error_dict, 'input_value_validator_list':
            patch_input_value_validator_list, 'output_validator_list':
            patch_output_validator_list, 'task_type': TaskType.NONE},
            'update': {'input_type': update_input_type, 'output_type': type
            .ReferenceType('com.vmware.nsx_policy.model_client',
            'IPSecVpnTunnelProfile'), 'errors': update_error_dict,
            'input_value_validator_list': update_input_value_validator_list,
            'output_validator_list': update_output_validator_list,
            'task_type': TaskType.NONE}}
        rest_metadata = {'delete': delete_rest_metadata, 'get':
            get_rest_metadata, 'list': list_rest_metadata, 'patch':
            patch_rest_metadata, 'update': update_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.ipsec_vpn_tunnel_profiles', config
            =config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)


class _PartnerServicesStub(ApiInterfaceStub):

    def __init__(self, config):
        get_input_type = type.StructType('operation-input', {'service_name':
            type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = []
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template=
            '/policy/api/v1/infra/partner-services/{service-name}',
            path_variables={'service_name': 'service-name'},
            query_parameters={}, content_type='application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = []
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/partner-services',
            path_variables={}, query_parameters={'cursor': 'cursor',
            'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        operations = {'get': {'input_type': get_input_type, 'output_type':
            type.ReferenceType('com.vmware.nsx_policy.model_client',
            'ServiceDefinition'), 'errors': get_error_dict,
            'input_value_validator_list': get_input_value_validator_list,
            'output_validator_list': get_output_validator_list, 'task_type':
            TaskType.NONE}, 'list': {'input_type': list_input_type,
            'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client',
            'ServiceInsertionServiceListResult'), 'errors': list_error_dict,
            'input_value_validator_list': list_input_value_validator_list,
            'output_validator_list': list_output_validator_list,
            'task_type': TaskType.NONE}}
        rest_metadata = {'get': get_rest_metadata, 'list': list_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.partner_services', config=config,
            operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)


class _PortMirroringProfilesStub(ApiInterfaceStub):

    def __init__(self, config):
        delete_input_type = type.StructType('operation-input', {
            'port_mirroring_profile_id': type.StringType()})
        delete_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template=
            '/policy/api/v1/infra/port-mirroring-profiles/{port-mirroring-profile-id}'
            , path_variables={'port_mirroring_profile_id':
            'port-mirroring-profile-id'}, query_parameters={}, content_type
            ='application/json')
        get_input_type = type.StructType('operation-input', {
            'port_mirroring_profile_id': type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template=
            '/policy/api/v1/infra/port-mirroring-profiles/{port-mirroring-profile-id}'
            , path_variables={'port_mirroring_profile_id':
            'port-mirroring-profile-id'}, query_parameters={}, content_type
            ='application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()), 'included_fields': type.
            OptionalType(type.StringType()), 'page_size': type.OptionalType
            (type.IntegerType()), 'sort_ascending': type.OptionalType(type.
            BooleanType()), 'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/port-mirroring-profiles',
            path_variables={}, query_parameters={'cursor': 'cursor',
            'included_fields': 'included_fields', 'page_size': 'page_size',
            'sort_ascending': 'sort_ascending', 'sort_by': 'sort_by'},
            content_type='application/json')
        patch_input_type = type.StructType('operation-input', {
            'port_mirroring_profile_id': type.StringType(),
            'port_mirroring_profile': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'PortMirroringProfile')})
        patch_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        patch_input_value_validator_list = [HasFieldsOfValidator()]
        patch_output_validator_list = []
        patch_rest_metadata = OperationRestMetadata(http_method='PATCH',
            url_template=
            '/policy/api/v1/infra/port-mirroring-profiles/{port-mirroring-profile-id}'
            , request_body_parameter='port_mirroring_profile',
            path_variables={'port_mirroring_profile_id':
            'port-mirroring-profile-id'}, query_parameters={}, content_type
            ='application/json')
        update_input_type = type.StructType('operation-input', {
            'port_mirroring_profile_id': type.StringType(),
            'port_mirroring_profile': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'PortMirroringProfile')})
        update_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(http_method='PUT',
            url_template=
            '/policy/api/v1/infra/port-mirroring-profiles/{port-mirroring-profile-id}'
            , request_body_parameter='port_mirroring_profile',
            path_variables={'port_mirroring_profile_id':
            'port-mirroring-profile-id'}, query_parameters={}, content_type
            ='application/json')
        operations = {'delete': {'input_type': delete_input_type,
            'output_type': type.VoidType(), 'errors': delete_error_dict,
            'input_value_validator_list': delete_input_value_validator_list,
            'output_validator_list': delete_output_validator_list,
            'task_type': TaskType.NONE}, 'get': {'input_type':
            get_input_type, 'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'PortMirroringProfile'),
            'errors': get_error_dict, 'input_value_validator_list':
            get_input_value_validator_list, 'output_validator_list':
            get_output_validator_list, 'task_type': TaskType.NONE}, 'list':
            {'input_type': list_input_type, 'output_type': type.
            ReferenceType('com.vmware.nsx_policy.model_client',
            'PortMirroringProfileListResult'), 'errors': list_error_dict,
            'input_value_validator_list': list_input_value_validator_list,
            'output_validator_list': list_output_validator_list,
            'task_type': TaskType.NONE}, 'patch': {'input_type':
            patch_input_type, 'output_type': type.VoidType(), 'errors':
            patch_error_dict, 'input_value_validator_list':
            patch_input_value_validator_list, 'output_validator_list':
            patch_output_validator_list, 'task_type': TaskType.NONE},
            'update': {'input_type': update_input_type, 'output_type': type
            .ReferenceType('com.vmware.nsx_policy.model_client',
            'PortMirroringProfile'), 'errors': update_error_dict,
            'input_value_validator_list': update_input_value_validator_list,
            'output_validator_list': update_output_validator_list,
            'task_type': TaskType.NONE}}
        rest_metadata = {'delete': delete_rest_metadata, 'get':
            get_rest_metadata, 'list': list_rest_metadata, 'patch':
            patch_rest_metadata, 'update': update_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.port_mirroring_profiles', config=
            config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)


class _SegmentsStub(ApiInterfaceStub):

    def __init__(self, config):
        delete_input_type = type.StructType('operation-input', {
            'segment_id': type.StringType()})
        delete_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template='/policy/api/v1/infra/segments/{segment-id}',
            path_variables={'segment_id': 'segment-id'}, query_parameters={
            }, content_type='application/json')
        delete_0_input_type = type.StructType('operation-input', {
            'segment_id': type.StringType()})
        delete_0_error_dict = {'com.vmware.vapi.std.errors.service_unavailable'
            : type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_0_input_value_validator_list = []
        delete_0_output_validator_list = []
        delete_0_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template=
            '/policy/api/v1/infra/segments/{segment-id}?force=true',
            path_variables={'segment_id': 'segment-id'}, query_parameters={
            }, content_type='application/json')
        get_input_type = type.StructType('operation-input', {'segment_id':
            type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/segments/{segment-id}',
            path_variables={'segment_id': 'segment-id'}, query_parameters={
            }, content_type='application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/segments', path_variables={},
            query_parameters={'cursor': 'cursor',
            'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        patch_input_type = type.StructType('operation-input', {'segment_id':
            type.StringType(), 'segment': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'Segment')})
        patch_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        patch_input_value_validator_list = [HasFieldsOfValidator()]
        patch_output_validator_list = []
        patch_rest_metadata = OperationRestMetadata(http_method='PATCH',
            url_template='/policy/api/v1/infra/segments/{segment-id}',
            request_body_parameter='segment', path_variables={'segment_id':
            'segment-id'}, query_parameters={}, content_type='application/json'
            )
        update_input_type = type.StructType('operation-input', {
            'segment_id': type.StringType(), 'segment': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'Segment')})
        update_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(http_method='PUT',
            url_template='/policy/api/v1/infra/segments/{segment-id}',
            request_body_parameter='segment', path_variables={'segment_id':
            'segment-id'}, query_parameters={}, content_type='application/json'
            )
        operations = {'delete': {'input_type': delete_input_type,
            'output_type': type.VoidType(), 'errors': delete_error_dict,
            'input_value_validator_list': delete_input_value_validator_list,
            'output_validator_list': delete_output_validator_list,
            'task_type': TaskType.NONE}, 'delete_0': {'input_type':
            delete_0_input_type, 'output_type': type.VoidType(), 'errors':
            delete_0_error_dict, 'input_value_validator_list':
            delete_0_input_value_validator_list, 'output_validator_list':
            delete_0_output_validator_list, 'task_type': TaskType.NONE},
            'get': {'input_type': get_input_type, 'output_type': type.
            ReferenceType('com.vmware.nsx_policy.model_client', 'Segment'),
            'errors': get_error_dict, 'input_value_validator_list':
            get_input_value_validator_list, 'output_validator_list':
            get_output_validator_list, 'task_type': TaskType.NONE}, 'list':
            {'input_type': list_input_type, 'output_type': type.
            ReferenceType('com.vmware.nsx_policy.model_client',
            'SegmentListResult'), 'errors': list_error_dict,
            'input_value_validator_list': list_input_value_validator_list,
            'output_validator_list': list_output_validator_list,
            'task_type': TaskType.NONE}, 'patch': {'input_type':
            patch_input_type, 'output_type': type.VoidType(), 'errors':
            patch_error_dict, 'input_value_validator_list':
            patch_input_value_validator_list, 'output_validator_list':
            patch_output_validator_list, 'task_type': TaskType.NONE},
            'update': {'input_type': update_input_type, 'output_type': type
            .ReferenceType('com.vmware.nsx_policy.model_client', 'Segment'),
            'errors': update_error_dict, 'input_value_validator_list':
            update_input_value_validator_list, 'output_validator_list':
            update_output_validator_list, 'task_type': TaskType.NONE}}
        rest_metadata = {'delete': delete_rest_metadata, 'delete_0':
            delete_0_rest_metadata, 'get': get_rest_metadata, 'list':
            list_rest_metadata, 'patch': patch_rest_metadata, 'update':
            update_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.segments', config=config,
            operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)


class _ServicesStub(ApiInterfaceStub):

    def __init__(self, config):
        delete_input_type = type.StructType('operation-input', {
            'service_id': type.StringType()})
        delete_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template='/policy/api/v1/infra/services/{service-id}',
            path_variables={'service_id': 'service-id'}, query_parameters={
            }, content_type='application/json')
        get_input_type = type.StructType('operation-input', {'service_id':
            type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/services/{service-id}',
            path_variables={'service_id': 'service-id'}, query_parameters={
            }, content_type='application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()), 'default_service': type.
            OptionalType(type.BooleanType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/services', path_variables={},
            query_parameters={'cursor': 'cursor', 'default_service':
            'default_service', 'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        patch_input_type = type.StructType('operation-input', {'service_id':
            type.StringType(), 'service': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'Service')})
        patch_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        patch_input_value_validator_list = [HasFieldsOfValidator()]
        patch_output_validator_list = []
        patch_rest_metadata = OperationRestMetadata(http_method='PATCH',
            url_template='/policy/api/v1/infra/services/{service-id}',
            request_body_parameter='service', path_variables={'service_id':
            'service-id'}, query_parameters={}, content_type='application/json'
            )
        update_input_type = type.StructType('operation-input', {
            'service_id': type.StringType(), 'service': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'Service')})
        update_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(http_method='PUT',
            url_template='/policy/api/v1/infra/services/{service-id}',
            request_body_parameter='service', path_variables={'service_id':
            'service-id'}, query_parameters={}, content_type='application/json'
            )
        operations = {'delete': {'input_type': delete_input_type,
            'output_type': type.VoidType(), 'errors': delete_error_dict,
            'input_value_validator_list': delete_input_value_validator_list,
            'output_validator_list': delete_output_validator_list,
            'task_type': TaskType.NONE}, 'get': {'input_type':
            get_input_type, 'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'Service'), 'errors':
            get_error_dict, 'input_value_validator_list':
            get_input_value_validator_list, 'output_validator_list':
            get_output_validator_list, 'task_type': TaskType.NONE}, 'list':
            {'input_type': list_input_type, 'output_type': type.
            ReferenceType('com.vmware.nsx_policy.model_client',
            'ServiceListResult'), 'errors': list_error_dict,
            'input_value_validator_list': list_input_value_validator_list,
            'output_validator_list': list_output_validator_list,
            'task_type': TaskType.NONE}, 'patch': {'input_type':
            patch_input_type, 'output_type': type.VoidType(), 'errors':
            patch_error_dict, 'input_value_validator_list':
            patch_input_value_validator_list, 'output_validator_list':
            patch_output_validator_list, 'task_type': TaskType.NONE},
            'update': {'input_type': update_input_type, 'output_type': type
            .ReferenceType('com.vmware.nsx_policy.model_client', 'Service'),
            'errors': update_error_dict, 'input_value_validator_list':
            update_input_value_validator_list, 'output_validator_list':
            update_output_validator_list, 'task_type': TaskType.NONE}}
        rest_metadata = {'delete': delete_rest_metadata, 'get':
            get_rest_metadata, 'list': list_rest_metadata, 'patch':
            patch_rest_metadata, 'update': update_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.services', config=config,
            operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)


class StubFactory(StubFactoryBase):
    _attrs = {'DhcpRelayConfigs': DhcpRelayConfigs, 'DhcpServerConfigs':
        DhcpServerConfigs, 'DnsForwarderZones': DnsForwarderZones,
        'Domains': Domains, 'Drafts': Drafts, 'GroupAssociations':
        GroupAssociations, 'IpfixCollectorProfiles': IpfixCollectorProfiles,
        'IpfixDfwCollectorProfiles': IpfixDfwCollectorProfiles,
        'IpfixDfwProfiles': IpfixDfwProfiles, 'IpfixL2CollectorProfiles':
        IpfixL2CollectorProfiles, 'IpfixL2Profiles': IpfixL2Profiles,
        'IpsecVpnDpdProfiles': IpsecVpnDpdProfiles, 'IpsecVpnIkeProfiles':
        IpsecVpnIkeProfiles, 'IpsecVpnTunnelProfiles':
        IpsecVpnTunnelProfiles, 'PartnerServices': PartnerServices,
        'PortMirroringProfiles': PortMirroringProfiles, 'Segments':
        Segments, 'Services': Services, 'domains':
        'com.vmware.nsx_policy.infra.domains_client.StubFactory', 'drafts':
        'com.vmware.nsx_policy.infra.drafts_client.StubFactory',
        'realized_state':
        'com.vmware.nsx_policy.infra.realized_state_client.StubFactory',
        'segments':
        'com.vmware.nsx_policy.infra.segments_client.StubFactory',
        'services':
        'com.vmware.nsx_policy.infra.services_client.StubFactory', 'sites':
        'com.vmware.nsx_policy.infra.sites_client.StubFactory', 'tier_0s':
        'com.vmware.nsx_policy.infra.tier_0s_client.StubFactory', 'tier_1s':
        'com.vmware.nsx_policy.infra.tier_1s_client.StubFactory'}

<mask token>
__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 DhcpRelayConfigs(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.dhcp_relay_configs'
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _DhcpRelayConfigsStub)
        self._VAPI_OPERATION_IDS = {}

    def delete(self, dhcp_relay_config_id):
        """
        Delete DHCP relay configuration

        :type  dhcp_relay_config_id: :class:`str`
        :param dhcp_relay_config_id: DHCP relay config ID (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete', {'dhcp_relay_config_id':
            dhcp_relay_config_id})

    def get(self, dhcp_relay_config_id):
        """
        Read DHCP relay configuration

        :type  dhcp_relay_config_id: :class:`str`
        :param dhcp_relay_config_id: DHCP relay config ID (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.DhcpRelayConfig`
        :return: com.vmware.nsx_policy.model.DhcpRelayConfig
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'dhcp_relay_config_id':
            dhcp_relay_config_id})

    def list(self, cursor=None, include_mark_for_delete_objects=None,
        included_fields=None, page_size=None, sort_ascending=None, sort_by=None
        ):
        """
        Paginated list of all DHCP relay config instances

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.DhcpRelayConfigListResult`
        :return: com.vmware.nsx_policy.model.DhcpRelayConfigListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'cursor': cursor,
            'include_mark_for_delete_objects':
            include_mark_for_delete_objects, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})

    def patch(self, dhcp_relay_config_id, dhcp_relay_config):
        """
        If DHCP relay config with the dhcp-relay-config-id is not already
        present, create a new DHCP relay config instance. If it already exists,
        update the DHCP relay config instance with specified attributes.

        :type  dhcp_relay_config_id: :class:`str`
        :param dhcp_relay_config_id: DHCP relay config ID (required)
        :type  dhcp_relay_config: :class:`com.vmware.nsx_policy.model_client.DhcpRelayConfig`
        :param dhcp_relay_config: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch', {'dhcp_relay_config_id':
            dhcp_relay_config_id, 'dhcp_relay_config': dhcp_relay_config})

    def update(self, dhcp_relay_config_id, dhcp_relay_config):
        """
        If DHCP relay config with the dhcp-relay-config-id is not already
        present, create a new DHCP relay config instance. If it already exists,
        replace the DHCP relay config instance with this object.

        :type  dhcp_relay_config_id: :class:`str`
        :param dhcp_relay_config_id: DHCP relay config ID (required)
        :type  dhcp_relay_config: :class:`com.vmware.nsx_policy.model_client.DhcpRelayConfig`
        :param dhcp_relay_config: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.DhcpRelayConfig`
        :return: com.vmware.nsx_policy.model.DhcpRelayConfig
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update', {'dhcp_relay_config_id':
            dhcp_relay_config_id, 'dhcp_relay_config': dhcp_relay_config})


class DhcpServerConfigs(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.dhcp_server_configs'
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _DhcpServerConfigsStub)
        self._VAPI_OPERATION_IDS = {}

    def delete(self, dhcp_server_config_id):
        """
        Delete DHCP server configuration

        :type  dhcp_server_config_id: :class:`str`
        :param dhcp_server_config_id: DHCP server config ID (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete', {'dhcp_server_config_id':
            dhcp_server_config_id})

    def get(self, dhcp_server_config_id):
        """
        Read DHCP server configuration

        :type  dhcp_server_config_id: :class:`str`
        :param dhcp_server_config_id: DHCP server config ID (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.DhcpServerConfig`
        :return: com.vmware.nsx_policy.model.DhcpServerConfig
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'dhcp_server_config_id':
            dhcp_server_config_id})

    def list(self, cursor=None, include_mark_for_delete_objects=None,
        included_fields=None, page_size=None, sort_ascending=None, sort_by=None
        ):
        """
        Paginated list of all DHCP server config instances

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.DhcpServerConfigListResult`
        :return: com.vmware.nsx_policy.model.DhcpServerConfigListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'cursor': cursor,
            'include_mark_for_delete_objects':
            include_mark_for_delete_objects, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})

    def patch(self, dhcp_server_config_id, dhcp_server_config):
        """
        If DHCP server config with the dhcp-server-config-id is not already
        present, create a new DHCP server config instance. If it already
        exists, update the DHCP server config instance with specified
        attributes. Realized entities of this API can be found using the path
        of Tier-0 that this config is applied on.

        :type  dhcp_server_config_id: :class:`str`
        :param dhcp_server_config_id: DHCP server config ID (required)
        :type  dhcp_server_config: :class:`com.vmware.nsx_policy.model_client.DhcpServerConfig`
        :param dhcp_server_config: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch', {'dhcp_server_config_id':
            dhcp_server_config_id, 'dhcp_server_config': dhcp_server_config})

    def update(self, dhcp_server_config_id, dhcp_server_config):
        """
        If DHCP server config with the dhcp-server-config-id is not already
        present, create a new DHCP server config instance. If it already
        exists, replace the DHCP server config instance with this object.
        Realized entities of this API can be found using the path of Tier-0
        that this config is applied on.

        :type  dhcp_server_config_id: :class:`str`
        :param dhcp_server_config_id: DHCP server config ID (required)
        :type  dhcp_server_config: :class:`com.vmware.nsx_policy.model_client.DhcpServerConfig`
        :param dhcp_server_config: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.DhcpServerConfig`
        :return: com.vmware.nsx_policy.model.DhcpServerConfig
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update', {'dhcp_server_config_id':
            dhcp_server_config_id, 'dhcp_server_config': dhcp_server_config})


class DnsForwarderZones(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.dns_forwarder_zones'
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _DnsForwarderZonesStub)
        self._VAPI_OPERATION_IDS = {}

    def delete(self, dns_forwarder_zone_id):
        """
        Delete the DNS Forwarder Zone

        :type  dns_forwarder_zone_id: :class:`str`
        :param dns_forwarder_zone_id: DNS Forwarder Zone ID (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete', {'dns_forwarder_zone_id':
            dns_forwarder_zone_id})

    def get(self, dns_forwarder_zone_id):
        """
        Read the DNS Forwarder Zone

        :type  dns_forwarder_zone_id: :class:`str`
        :param dns_forwarder_zone_id: DNS Forwarder Zone ID (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.PolicyDnsForwarderZone`
        :return: com.vmware.nsx_policy.model.PolicyDnsForwarderZone
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'dns_forwarder_zone_id':
            dns_forwarder_zone_id})

    def list(self, cursor=None, include_mark_for_delete_objects=None,
        included_fields=None, page_size=None, sort_ascending=None, sort_by=None
        ):
        """
        Paginated list of all Dns Forwarder Zones

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.PolicyDnsForwarderZoneListResult`
        :return: com.vmware.nsx_policy.model.PolicyDnsForwarderZoneListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'cursor': cursor,
            'include_mark_for_delete_objects':
            include_mark_for_delete_objects, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})

    def patch(self, dns_forwarder_zone_id, policy_dns_forwarder_zone):
        """
        Create or update the DNS Forwarder Zone

        :type  dns_forwarder_zone_id: :class:`str`
        :param dns_forwarder_zone_id: DNS Forwarder Zone ID (required)
        :type  policy_dns_forwarder_zone: :class:`com.vmware.nsx_policy.model_client.PolicyDnsForwarderZone`
        :param policy_dns_forwarder_zone: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch', {'dns_forwarder_zone_id':
            dns_forwarder_zone_id, 'policy_dns_forwarder_zone':
            policy_dns_forwarder_zone})

    def update(self, dns_forwarder_zone_id, policy_dns_forwarder_zone):
        """
        Create or update the DNS Forwarder Zone

        :type  dns_forwarder_zone_id: :class:`str`
        :param dns_forwarder_zone_id: DNS Forwarder Zone ID (required)
        :type  policy_dns_forwarder_zone: :class:`com.vmware.nsx_policy.model_client.PolicyDnsForwarderZone`
        :param policy_dns_forwarder_zone: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.PolicyDnsForwarderZone`
        :return: com.vmware.nsx_policy.model.PolicyDnsForwarderZone
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update', {'dns_forwarder_zone_id':
            dns_forwarder_zone_id, 'policy_dns_forwarder_zone':
            policy_dns_forwarder_zone})


class Domains(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.domains'
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _DomainsStub)
        self._VAPI_OPERATION_IDS = {}

    def get(self, domain_id):
        """
        Read a domain.

        :type  domain_id: :class:`str`
        :param domain_id: Domain ID (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.Domain`
        :return: com.vmware.nsx_policy.model.Domain
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'domain_id': domain_id})

    def list(self, cursor=None, include_mark_for_delete_objects=None,
        included_fields=None, page_size=None, sort_ascending=None, sort_by=None
        ):
        """
        Paginated list of all domains for infra.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.DomainListResult`
        :return: com.vmware.nsx_policy.model.DomainListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'cursor': cursor,
            'include_mark_for_delete_objects':
            include_mark_for_delete_objects, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})


class Drafts(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.drafts'
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _DraftsStub)
        self._VAPI_OPERATION_IDS = {}

    def abort(self, draft_id):
        """
        If there is a failure during publish, the admin can choose to abort the
        publishing attempts. This will bring back the system to the current
        configuration, i.e just before the publish was invoked. If draft
        publishing is not in progress or already completed, then this is a
        NO-OP

        :type  draft_id: :class:`str`
        :param draft_id: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('abort', {'draft_id': draft_id})

    def delete(self, draft_id):
        """
        Delete a manual draft.

        :type  draft_id: :class:`str`
        :param draft_id: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete', {'draft_id': draft_id})

    def get(self, draft_id):
        """
        Read a draft for a given draft identifier.

        :type  draft_id: :class:`str`
        :param draft_id: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.PolicyDraft`
        :return: com.vmware.nsx_policy.model.PolicyDraft
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'draft_id': draft_id})

    def list(self, auto_drafts=None, cursor=None,
        include_mark_for_delete_objects=None, included_fields=None,
        page_size=None, sort_ascending=None, sort_by=None):
        """
        List policy drafts.

        :type  auto_drafts: :class:`bool` or ``None``
        :param auto_drafts: Fetch list of draft based on is_auto_draft flag (optional)
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.PolicyDraftListResult`
        :return: com.vmware.nsx_policy.model.PolicyDraftListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'auto_drafts': auto_drafts, 'cursor':
            cursor, 'include_mark_for_delete_objects':
            include_mark_for_delete_objects, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})

    def patch(self, draft_id, policy_draft):
        """
        Create a new manual draft if the specified draft id does not correspond
        to an existing draft. Update the manual draft otherwise. Auto draft can
        not be updated.

        :type  draft_id: :class:`str`
        :param draft_id: (required)
        :type  policy_draft: :class:`com.vmware.nsx_policy.model_client.PolicyDraft`
        :param policy_draft: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch', {'draft_id': draft_id, 'policy_draft':
            policy_draft})

    def publish(self, draft_id, infra):
        """
        Read a draft and publish it by applying changes onto current
        configuration.

        :type  draft_id: :class:`str`
        :param draft_id: (required)
        :type  infra: :class:`com.vmware.nsx_policy.model_client.Infra`
        :param infra: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('publish', {'draft_id': draft_id, 'infra': infra})

    def update(self, draft_id, policy_draft):
        """
        Create a new manual draft if the specified draft id does not correspond
        to an existing draft. Update the manual draft otherwise. Auto draft can
        not be updated.

        :type  draft_id: :class:`str`
        :param draft_id: (required)
        :type  policy_draft: :class:`com.vmware.nsx_policy.model_client.PolicyDraft`
        :param policy_draft: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.PolicyDraft`
        :return: com.vmware.nsx_policy.model.PolicyDraft
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update', {'draft_id': draft_id, 'policy_draft':
            policy_draft})


class GroupAssociations(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.group_associations'
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _GroupAssociationsStub)
        self._VAPI_OPERATION_IDS = {}

    def list(self, intent_path, cursor=None, enforcement_point_path=None,
        include_mark_for_delete_objects=None, included_fields=None,
        page_size=None, sort_ascending=None, sort_by=None):
        """
        Get policy groups for which the given object is a member.

        :type  intent_path: :class:`str`
        :param intent_path: String path of the intent object (required)
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  enforcement_point_path: :class:`str` or ``None``
        :param enforcement_point_path: String Path of the enforcement point (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.PolicyResourceReferenceForEPListResult`
        :return: com.vmware.nsx_policy.model.PolicyResourceReferenceForEPListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'intent_path': intent_path, 'cursor':
            cursor, 'enforcement_point_path': enforcement_point_path,
            'include_mark_for_delete_objects':
            include_mark_for_delete_objects, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})


class IpfixCollectorProfiles(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.ipfix_collector_profiles'
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _IpfixCollectorProfilesStub)
        self._VAPI_OPERATION_IDS = {}

    def delete(self, ipfix_collector_profile_id):
        """
        API deletes IPFIX collector profile. Flow forwarding to collector will
        be stopped. This API is deprecated. Please use the following API:
        https://<policy-mgr>/policy/api/v1/infra/ipfix-l2-collector-profiles

        :type  ipfix_collector_profile_id: :class:`str`
        :param ipfix_collector_profile_id: IPFIX collector Profile id (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete', {'ipfix_collector_profile_id':
            ipfix_collector_profile_id})

    def get(self, ipfix_collector_profile_id):
        """
        API will return details of IPFIX collector profile. If profile does not
        exist, it will return 404. This API is deprecated. Please use the
        following API:
        https://<policy-mgr>/policy/api/v1/infra/ipfix-l2-collector-profiles

        :type  ipfix_collector_profile_id: :class:`str`
        :param ipfix_collector_profile_id: IPFIX collector profile id (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXCollectorProfile`
        :return: com.vmware.nsx_policy.model.IPFIXCollectorProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'ipfix_collector_profile_id':
            ipfix_collector_profile_id})

    def list(self, cursor=None, include_mark_for_delete_objects=None,
        included_fields=None, page_size=None, sort_ascending=None, sort_by=None
        ):
        """
        API will provide list of all IPFIX collector profiles and their
        details. This API is deprecated. Please use the following API:
        https://<policy-mgr>/policy/api/v1/infra/ipfix-l2-collector-profiles

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXCollectorProfileListResult`
        :return: com.vmware.nsx_policy.model.IPFIXCollectorProfileListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'cursor': cursor,
            'include_mark_for_delete_objects':
            include_mark_for_delete_objects, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})

    def patch(self, ipfix_collector_profile_id, i_pfix_collector_profile):
        """
        Create a new IPFIX collector profile if the IPFIX collector profile
        with given id does not already exist. If the IPFIX collector profile
        with the given id already exists, patch with the existing IPFIX
        collector profile. This API is deprecated. Please use the following
        API:
        https://<policy-mgr>/policy/api/v1/infra/ipfix-l2-collector-profiles

        :type  ipfix_collector_profile_id: :class:`str`
        :param ipfix_collector_profile_id: IPFIX collector profile id (required)
        :type  i_pfix_collector_profile: :class:`com.vmware.nsx_policy.model_client.IPFIXCollectorProfile`
        :param i_pfix_collector_profile: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch', {'ipfix_collector_profile_id':
            ipfix_collector_profile_id, 'i_pfix_collector_profile':
            i_pfix_collector_profile})

    def update(self, ipfix_collector_profile_id, i_pfix_collector_profile):
        """
        Create or Replace IPFIX collector profile. IPFIX data will be sent to
        IPFIX collector port. This API is deprecated. Please use the following
        API:
        https://<policy-mgr>/policy/api/v1/infra/ipfix-l2-collector-profiles

        :type  ipfix_collector_profile_id: :class:`str`
        :param ipfix_collector_profile_id: IPFIX collector profile id (required)
        :type  i_pfix_collector_profile: :class:`com.vmware.nsx_policy.model_client.IPFIXCollectorProfile`
        :param i_pfix_collector_profile: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXCollectorProfile`
        :return: com.vmware.nsx_policy.model.IPFIXCollectorProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update', {'ipfix_collector_profile_id':
            ipfix_collector_profile_id, 'i_pfix_collector_profile':
            i_pfix_collector_profile})


class IpfixDfwCollectorProfiles(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = (
        'com.vmware.nsx_policy.infra.ipfix_dfw_collector_profiles')
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _IpfixDfwCollectorProfilesStub)
        self._VAPI_OPERATION_IDS = {}

    def delete(self, ipfix_dfw_collector_profile_id):
        """
        API deletes IPFIX dfw collector profile. Flow forwarding to collector
        will be stopped.

        :type  ipfix_dfw_collector_profile_id: :class:`str`
        :param ipfix_dfw_collector_profile_id: IPFIX dfw collector Profile id (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete', {'ipfix_dfw_collector_profile_id':
            ipfix_dfw_collector_profile_id})

    def get(self, ipfix_dfw_collector_profile_id):
        """
        API will return details of IPFIX dfw collector profile. If profile does
        not exist, it will return 404.

        :type  ipfix_dfw_collector_profile_id: :class:`str`
        :param ipfix_dfw_collector_profile_id: IPFIX dfw collector profile id (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXDFWCollectorProfile`
        :return: com.vmware.nsx_policy.model.IPFIXDFWCollectorProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'ipfix_dfw_collector_profile_id':
            ipfix_dfw_collector_profile_id})

    def list(self, cursor=None, include_mark_for_delete_objects=None,
        included_fields=None, page_size=None, sort_ascending=None, sort_by=None
        ):
        """
        API will provide list of all IPFIX dfw collector profiles and their
        details.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXDFWCollectorProfileListResult`
        :return: com.vmware.nsx_policy.model.IPFIXDFWCollectorProfileListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'cursor': cursor,
            'include_mark_for_delete_objects':
            include_mark_for_delete_objects, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})

    def patch(self, ipfix_dfw_collector_profile_id, i_pfixdfw_collector_profile
        ):
        """
        Create a new IPFIX dfw collector profile if the IPFIX dfw collector
        profile with given id does not already exist. If the IPFIX dfw
        collector profile with the given id already exists, patch with the
        existing IPFIX dfw collector profile.

        :type  ipfix_dfw_collector_profile_id: :class:`str`
        :param ipfix_dfw_collector_profile_id: (required)
        :type  i_pfixdfw_collector_profile: :class:`com.vmware.nsx_policy.model_client.IPFIXDFWCollectorProfile`
        :param i_pfixdfw_collector_profile: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch', {'ipfix_dfw_collector_profile_id':
            ipfix_dfw_collector_profile_id, 'i_pfixdfw_collector_profile':
            i_pfixdfw_collector_profile})

    def update(self, ipfix_dfw_collector_profile_id,
        i_pfixdfw_collector_profile):
        """
        Create or Replace IPFIX dfw collector profile. IPFIX data will be sent
        to IPFIX collector port.

        :type  ipfix_dfw_collector_profile_id: :class:`str`
        :param ipfix_dfw_collector_profile_id: IPFIX dfw collector profile id (required)
        :type  i_pfixdfw_collector_profile: :class:`com.vmware.nsx_policy.model_client.IPFIXDFWCollectorProfile`
        :param i_pfixdfw_collector_profile: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXDFWCollectorProfile`
        :return: com.vmware.nsx_policy.model.IPFIXDFWCollectorProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update', {'ipfix_dfw_collector_profile_id':
            ipfix_dfw_collector_profile_id, 'i_pfixdfw_collector_profile':
            i_pfixdfw_collector_profile})


class IpfixDfwProfiles(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.ipfix_dfw_profiles'
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _IpfixDfwProfilesStub)
        self._VAPI_OPERATION_IDS = {}

    def delete(self, ipfix_dfw_profile_id):
        """
        API deletes IPFIX DFW Profile. Selected IPFIX Collectors will stop
        receiving flows.

        :type  ipfix_dfw_profile_id: :class:`str`
        :param ipfix_dfw_profile_id: IPFIX DFW Profile ID (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete', {'ipfix_dfw_profile_id':
            ipfix_dfw_profile_id})

    def get(self, ipfix_dfw_profile_id):
        """
        API will return details of IPFIX DFW profile.

        :type  ipfix_dfw_profile_id: :class:`str`
        :param ipfix_dfw_profile_id: IPFIX DFW collection id (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXDFWProfile`
        :return: com.vmware.nsx_policy.model.IPFIXDFWProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'ipfix_dfw_profile_id':
            ipfix_dfw_profile_id})

    def list(self, cursor=None, include_mark_for_delete_objects=None,
        included_fields=None, page_size=None, sort_ascending=None, sort_by=None
        ):
        """
        API provides list IPFIX DFW profiles available on selected logical DFW.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXDFWProfileListResult`
        :return: com.vmware.nsx_policy.model.IPFIXDFWProfileListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'cursor': cursor,
            'include_mark_for_delete_objects':
            include_mark_for_delete_objects, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})

    def patch(self, ipfix_dfw_profile_id, i_pfixdfw_profile):
        """
        Create a new IPFIX DFW profile if the IPFIX DFW profile with given id
        does not already exist. If the IPFIX DFW profile with the given id
        already exists, patch with the existing IPFIX DFW profile.

        :type  ipfix_dfw_profile_id: :class:`str`
        :param ipfix_dfw_profile_id: IPFIX DFW Profile ID (required)
        :type  i_pfixdfw_profile: :class:`com.vmware.nsx_policy.model_client.IPFIXDFWProfile`
        :param i_pfixdfw_profile: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch', {'ipfix_dfw_profile_id':
            ipfix_dfw_profile_id, 'i_pfixdfw_profile': i_pfixdfw_profile})

    def update(self, ipfix_dfw_profile_id, i_pfixdfw_profile):
        """
        Create or replace IPFIX DFW profile. Config will start forwarding data
        to provided IPFIX DFW collector.

        :type  ipfix_dfw_profile_id: :class:`str`
        :param ipfix_dfw_profile_id: IPFIX DFW Profile ID (required)
        :type  i_pfixdfw_profile: :class:`com.vmware.nsx_policy.model_client.IPFIXDFWProfile`
        :param i_pfixdfw_profile: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXDFWProfile`
        :return: com.vmware.nsx_policy.model.IPFIXDFWProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update', {'ipfix_dfw_profile_id':
            ipfix_dfw_profile_id, 'i_pfixdfw_profile': i_pfixdfw_profile})


class IpfixL2CollectorProfiles(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = (
        'com.vmware.nsx_policy.infra.ipfix_l2_collector_profiles')
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _IpfixL2CollectorProfilesStub)
        self._VAPI_OPERATION_IDS = {}

    def delete(self, ipfix_l2_collector_profile_id):
        """
        API deletes IPFIX collector profile. Flow forwarding to collector will
        be stopped.

        :type  ipfix_l2_collector_profile_id: :class:`str`
        :param ipfix_l2_collector_profile_id: IPFIX collector Profile id (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete', {'ipfix_l2_collector_profile_id':
            ipfix_l2_collector_profile_id})

    def get(self, ipfix_l2_collector_profile_id):
        """
        API will return details of IPFIX collector profile.

        :type  ipfix_l2_collector_profile_id: :class:`str`
        :param ipfix_l2_collector_profile_id: IPFIX collector profile id (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXL2CollectorProfile`
        :return: com.vmware.nsx_policy.model.IPFIXL2CollectorProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'ipfix_l2_collector_profile_id':
            ipfix_l2_collector_profile_id})

    def list(self, cursor=None, include_mark_for_delete_objects=None,
        included_fields=None, page_size=None, sort_ascending=None, sort_by=None
        ):
        """
        API will provide list of all IPFIX collector profiles and their
        details.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXL2CollectorProfileListResult`
        :return: com.vmware.nsx_policy.model.IPFIXL2CollectorProfileListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'cursor': cursor,
            'include_mark_for_delete_objects':
            include_mark_for_delete_objects, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})

    def patch(self, ipfix_l2_collector_profile_id, i_pfix_l2_collector_profile
        ):
        """
        Create a new IPFIX collector profile if the IPFIX collector profile
        with given id does not already exist. If the IPFIX collector profile
        with the given id already exists, patch with the existing IPFIX
        collector profile.

        :type  ipfix_l2_collector_profile_id: :class:`str`
        :param ipfix_l2_collector_profile_id: IPFIX collector profile id (required)
        :type  i_pfix_l2_collector_profile: :class:`com.vmware.nsx_policy.model_client.IPFIXL2CollectorProfile`
        :param i_pfix_l2_collector_profile: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch', {'ipfix_l2_collector_profile_id':
            ipfix_l2_collector_profile_id, 'i_pfix_l2_collector_profile':
            i_pfix_l2_collector_profile})

    def update(self, ipfix_l2_collector_profile_id, i_pfix_l2_collector_profile
        ):
        """
        Create or Replace IPFIX collector profile. IPFIX data will be sent to
        IPFIX collector.

        :type  ipfix_l2_collector_profile_id: :class:`str`
        :param ipfix_l2_collector_profile_id: IPFIX collector profile id (required)
        :type  i_pfix_l2_collector_profile: :class:`com.vmware.nsx_policy.model_client.IPFIXL2CollectorProfile`
        :param i_pfix_l2_collector_profile: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXL2CollectorProfile`
        :return: com.vmware.nsx_policy.model.IPFIXL2CollectorProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update', {'ipfix_l2_collector_profile_id':
            ipfix_l2_collector_profile_id, 'i_pfix_l2_collector_profile':
            i_pfix_l2_collector_profile})


class IpfixL2Profiles(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.ipfix_l2_profiles'
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _IpfixL2ProfilesStub)
        self._VAPI_OPERATION_IDS = {}

    def delete(self, ipfix_l2_profile_id):
        """
        API deletes IPFIX L2 Profile. Flow forwarding to selected collector
        will be stopped.

        :type  ipfix_l2_profile_id: :class:`str`
        :param ipfix_l2_profile_id: IPFIX L2 Profile ID (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete', {'ipfix_l2_profile_id':
            ipfix_l2_profile_id})

    def get(self, ipfix_l2_profile_id):
        """
        API will return details of IPFIX L2 profile.

        :type  ipfix_l2_profile_id: :class:`str`
        :param ipfix_l2_profile_id: IPFIX L2 profile id (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXL2Profile`
        :return: com.vmware.nsx_policy.model.IPFIXL2Profile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'ipfix_l2_profile_id': ipfix_l2_profile_id}
            )

    def list(self, cursor=None, include_mark_for_delete_objects=None,
        included_fields=None, page_size=None, sort_ascending=None, sort_by=None
        ):
        """
        API provides list IPFIX L2 Profiles available on selected logical l2.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXL2ProfileListResult`
        :return: com.vmware.nsx_policy.model.IPFIXL2ProfileListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'cursor': cursor,
            'include_mark_for_delete_objects':
            include_mark_for_delete_objects, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})

    def patch(self, ipfix_l2_profile_id, i_pfix_l2_profile):
        """
        Create a new IPFIX L2 profile if the IPFIX L2 profile with given id
        does not already exist. If the IPFIX L2 profile with the given id
        already exists, patch with the existing IPFIX L2 profile.

        :type  ipfix_l2_profile_id: :class:`str`
        :param ipfix_l2_profile_id: IPFIX L2 Profile ID (required)
        :type  i_pfix_l2_profile: :class:`com.vmware.nsx_policy.model_client.IPFIXL2Profile`
        :param i_pfix_l2_profile: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch', {'ipfix_l2_profile_id':
            ipfix_l2_profile_id, 'i_pfix_l2_profile': i_pfix_l2_profile})

    def update(self, ipfix_l2_profile_id, i_pfix_l2_profile):
        """
        Create or replace IPFIX L2 Profile. Profile is reusable entity. Single
        profile can attached multiple bindings e.g group, segment and port.

        :type  ipfix_l2_profile_id: :class:`str`
        :param ipfix_l2_profile_id: IPFIX L2 Profile ID (required)
        :type  i_pfix_l2_profile: :class:`com.vmware.nsx_policy.model_client.IPFIXL2Profile`
        :param i_pfix_l2_profile: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXL2Profile`
        :return: com.vmware.nsx_policy.model.IPFIXL2Profile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update', {'ipfix_l2_profile_id':
            ipfix_l2_profile_id, 'i_pfix_l2_profile': i_pfix_l2_profile})


class IpsecVpnDpdProfiles(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.ipsec_vpn_dpd_profiles'
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _IpsecVpnDpdProfilesStub)
        self._VAPI_OPERATION_IDS = {}

    def delete(self, dpd_profile_id):
        """
        Delete custom dead peer detection (DPD) profile. Profile can not be
        deleted if profile has references to it.

        :type  dpd_profile_id: :class:`str`
        :param dpd_profile_id: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete', {'dpd_profile_id': dpd_profile_id})

    def get(self, dpd_profile_id):
        """
        Get custom dead peer detection (DPD) profile, given the particular id.

        :type  dpd_profile_id: :class:`str`
        :param dpd_profile_id: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPSecVpnDpdProfile`
        :return: com.vmware.nsx_policy.model.IPSecVpnDpdProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'dpd_profile_id': dpd_profile_id})

    def list(self, cursor=None, include_mark_for_delete_objects=None,
        included_fields=None, page_size=None, sort_ascending=None, sort_by=None
        ):
        """
        Get paginated list of all DPD Profiles.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPSecVpnDpdProfileListResult`
        :return: com.vmware.nsx_policy.model.IPSecVpnDpdProfileListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'cursor': cursor,
            'include_mark_for_delete_objects':
            include_mark_for_delete_objects, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})

    def patch(self, dpd_profile_id, ip_sec_vpn_dpd_profile):
        """
        Create or patch dead peer detection (DPD) profile. Any change in
        profile affects all sessions consuming this profile. System will be
        provisioned with system owned editable default DPD profile. Any change
        in profile affects all sessions consuming this profile.

        :type  dpd_profile_id: :class:`str`
        :param dpd_profile_id: (required)
        :type  ip_sec_vpn_dpd_profile: :class:`com.vmware.nsx_policy.model_client.IPSecVpnDpdProfile`
        :param ip_sec_vpn_dpd_profile: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch', {'dpd_profile_id': dpd_profile_id,
            'ip_sec_vpn_dpd_profile': ip_sec_vpn_dpd_profile})

    def update(self, dpd_profile_id, ip_sec_vpn_dpd_profile):
        """
        Create or patch dead peer detection (DPD) profile. Any change in
        profile affects all sessions consuming this profile. System will be
        provisioned with system owned editable default DPD profile. Any change
        in profile affects all sessions consuming this profile. Revision is
        optional for creation and required for update.

        :type  dpd_profile_id: :class:`str`
        :param dpd_profile_id: (required)
        :type  ip_sec_vpn_dpd_profile: :class:`com.vmware.nsx_policy.model_client.IPSecVpnDpdProfile`
        :param ip_sec_vpn_dpd_profile: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPSecVpnDpdProfile`
        :return: com.vmware.nsx_policy.model.IPSecVpnDpdProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update', {'dpd_profile_id': dpd_profile_id,
            'ip_sec_vpn_dpd_profile': ip_sec_vpn_dpd_profile})


class IpsecVpnIkeProfiles(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.ipsec_vpn_ike_profiles'
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _IpsecVpnIkeProfilesStub)
        self._VAPI_OPERATION_IDS = {}

    def delete(self, ike_profile_id):
        """
        Delete custom IKE Profile. Profile can not be deleted if profile has
        references to it.

        :type  ike_profile_id: :class:`str`
        :param ike_profile_id: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete', {'ike_profile_id': ike_profile_id})

    def get(self, ike_profile_id):
        """
        Get custom IKE Profile, given the particular id.

        :type  ike_profile_id: :class:`str`
        :param ike_profile_id: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPSecVpnIkeProfile`
        :return: com.vmware.nsx_policy.model.IPSecVpnIkeProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'ike_profile_id': ike_profile_id})

    def list(self, cursor=None, include_mark_for_delete_objects=None,
        included_fields=None, page_size=None, sort_ascending=None, sort_by=None
        ):
        """
        Get paginated list of all IKE Profiles.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPSecVpnIkeProfileListResult`
        :return: com.vmware.nsx_policy.model.IPSecVpnIkeProfileListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'cursor': cursor,
            'include_mark_for_delete_objects':
            include_mark_for_delete_objects, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})

    def patch(self, ike_profile_id, ip_sec_vpn_ike_profile):
        """
        Create or patch custom internet key exchange (IKE) Profile. IKE Profile
        is a reusable profile that captures IKE and phase one negotiation
        parameters. System will be pre provisioned with system owned editable
        default IKE profile and suggested set of profiles that can be used for
        peering with popular remote peers like AWS VPN. User can create custom
        profiles as needed. Any change in profile affects all sessions
        consuming this profile.

        :type  ike_profile_id: :class:`str`
        :param ike_profile_id: (required)
        :type  ip_sec_vpn_ike_profile: :class:`com.vmware.nsx_policy.model_client.IPSecVpnIkeProfile`
        :param ip_sec_vpn_ike_profile: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch', {'ike_profile_id': ike_profile_id,
            'ip_sec_vpn_ike_profile': ip_sec_vpn_ike_profile})

    def update(self, ike_profile_id, ip_sec_vpn_ike_profile):
        """
        Create or fully replace custom internet key exchange (IKE) Profile. IKE
        Profile is a reusable profile that captures IKE and phase one
        negotiation parameters. System will be pre provisioned with system
        owned editable default IKE profile and suggested set of profiles that
        can be used for peering with popular remote peers like AWS VPN. User
        can create custom profiles as needed. Any change in profile affects all
        sessions consuming this profile. Revision is optional for creation and
        required for update.

        :type  ike_profile_id: :class:`str`
        :param ike_profile_id: (required)
        :type  ip_sec_vpn_ike_profile: :class:`com.vmware.nsx_policy.model_client.IPSecVpnIkeProfile`
        :param ip_sec_vpn_ike_profile: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPSecVpnIkeProfile`
        :return: com.vmware.nsx_policy.model.IPSecVpnIkeProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update', {'ike_profile_id': ike_profile_id,
            'ip_sec_vpn_ike_profile': ip_sec_vpn_ike_profile})


class IpsecVpnTunnelProfiles(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.ipsec_vpn_tunnel_profiles'
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _IpsecVpnTunnelProfilesStub)
        self._VAPI_OPERATION_IDS = {}

    def delete(self, tunnel_profile_id):
        """
        Delete custom IPSec tunnel Profile. Profile can not be deleted if
        profile has references to it.

        :type  tunnel_profile_id: :class:`str`
        :param tunnel_profile_id: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete', {'tunnel_profile_id': tunnel_profile_id})

    def get(self, tunnel_profile_id):
        """
        Get custom IPSec tunnel Profile, given the particular id.

        :type  tunnel_profile_id: :class:`str`
        :param tunnel_profile_id: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPSecVpnTunnelProfile`
        :return: com.vmware.nsx_policy.model.IPSecVpnTunnelProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'tunnel_profile_id': tunnel_profile_id})

    def list(self, cursor=None, include_mark_for_delete_objects=None,
        included_fields=None, page_size=None, sort_ascending=None, sort_by=None
        ):
        """
        Get paginated list of all IPSec tunnel Profiles.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPSecVpnTunnelProfileListResult`
        :return: com.vmware.nsx_policy.model.IPSecVpnTunnelProfileListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'cursor': cursor,
            'include_mark_for_delete_objects':
            include_mark_for_delete_objects, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})

    def patch(self, tunnel_profile_id, ip_sec_vpn_tunnel_profile):
        """
        Create or patch custom IPSec tunnel profile. IPSec tunnel profile is a
        reusable profile that captures phase two negotiation parameters and
        tunnel properties. System will be provisioned with system owned
        editable default IPSec tunnel profile. Any change in profile affects
        all sessions consuming this profile.

        :type  tunnel_profile_id: :class:`str`
        :param tunnel_profile_id: (required)
        :type  ip_sec_vpn_tunnel_profile: :class:`com.vmware.nsx_policy.model_client.IPSecVpnTunnelProfile`
        :param ip_sec_vpn_tunnel_profile: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch', {'tunnel_profile_id':
            tunnel_profile_id, 'ip_sec_vpn_tunnel_profile':
            ip_sec_vpn_tunnel_profile})

    def update(self, tunnel_profile_id, ip_sec_vpn_tunnel_profile):
        """
        Create or fully replace custom IPSec tunnel profile. IPSec tunnel
        profile is a reusable profile that captures phase two negotiation
        parameters and tunnel properties. System will be provisioned with
        system owned editable default IPSec tunnel profile. Any change in
        profile affects all sessions consuming this profile. Revision is
        optional for creation and required for update.

        :type  tunnel_profile_id: :class:`str`
        :param tunnel_profile_id: (required)
        :type  ip_sec_vpn_tunnel_profile: :class:`com.vmware.nsx_policy.model_client.IPSecVpnTunnelProfile`
        :param ip_sec_vpn_tunnel_profile: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPSecVpnTunnelProfile`
        :return: com.vmware.nsx_policy.model.IPSecVpnTunnelProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update', {'tunnel_profile_id':
            tunnel_profile_id, 'ip_sec_vpn_tunnel_profile':
            ip_sec_vpn_tunnel_profile})


class PartnerServices(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.partner_services'
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _PartnerServicesStub)
        self._VAPI_OPERATION_IDS = {}

    def get(self, service_name):
        """
        Read the specific partner service identified by provided name.

        :type  service_name: :class:`str`
        :param service_name: Name of the service (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.ServiceDefinition`
        :return: com.vmware.nsx_policy.model.ServiceDefinition
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'service_name': service_name})

    def list(self, cursor=None, include_mark_for_delete_objects=None,
        included_fields=None, page_size=None, sort_ascending=None, sort_by=None
        ):
        """
        Read all the partner services available for service insertion

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.ServiceInsertionServiceListResult`
        :return: com.vmware.nsx_policy.model.ServiceInsertionServiceListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'cursor': cursor,
            'include_mark_for_delete_objects':
            include_mark_for_delete_objects, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})


class PortMirroringProfiles(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.port_mirroring_profiles'
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _PortMirroringProfilesStub)
        self._VAPI_OPERATION_IDS = {}

    def delete(self, port_mirroring_profile_id):
        """
        API will delete port mirroring profile. Mirroring from source to
        destination ports will be stopped.

        :type  port_mirroring_profile_id: :class:`str`
        :param port_mirroring_profile_id: Port Mirroring Profile Id (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete', {'port_mirroring_profile_id':
            port_mirroring_profile_id})

    def get(self, port_mirroring_profile_id):
        """
        API will return details of port mirroring profile.

        :type  port_mirroring_profile_id: :class:`str`
        :param port_mirroring_profile_id: Port Mirroring Profile Id (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.PortMirroringProfile`
        :return: com.vmware.nsx_policy.model.PortMirroringProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'port_mirroring_profile_id':
            port_mirroring_profile_id})

    def list(self, cursor=None, included_fields=None, page_size=None,
        sort_ascending=None, sort_by=None):
        """
        API will list all port mirroring profiles group.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.PortMirroringProfileListResult`
        :return: com.vmware.nsx_policy.model.PortMirroringProfileListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'cursor': cursor, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})

    def patch(self, port_mirroring_profile_id, port_mirroring_profile):
        """
        Create a new Port Mirroring Profile if the Port Mirroring Profile with
        given id does not already exist. If the Port Mirroring Profile with the
        given id already exists, patch with the existing Port Mirroring
        Profile. Realized entities of this API can be found using the path of
        monitoring profile binding map that is used to apply this profile.

        :type  port_mirroring_profile_id: :class:`str`
        :param port_mirroring_profile_id: Port Mirroring Profile Id (required)
        :type  port_mirroring_profile: :class:`com.vmware.nsx_policy.model_client.PortMirroringProfile`
        :param port_mirroring_profile: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch', {'port_mirroring_profile_id':
            port_mirroring_profile_id, 'port_mirroring_profile':
            port_mirroring_profile})

    def update(self, port_mirroring_profile_id, port_mirroring_profile):
        """
        Create or Replace port mirroring profile. Packets will be mirrored from
        source group, segment, port to destination group. Realized entities of
        this API can be found using the path of monitoring profile binding map
        that is used to apply this profile.

        :type  port_mirroring_profile_id: :class:`str`
        :param port_mirroring_profile_id: Port Mirroring Profiles Id (required)
        :type  port_mirroring_profile: :class:`com.vmware.nsx_policy.model_client.PortMirroringProfile`
        :param port_mirroring_profile: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.PortMirroringProfile`
        :return: com.vmware.nsx_policy.model.PortMirroringProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update', {'port_mirroring_profile_id':
            port_mirroring_profile_id, 'port_mirroring_profile':
            port_mirroring_profile})


class Segments(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.segments'
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _SegmentsStub)
        self._VAPI_OPERATION_IDS = {}

    def delete(self, segment_id):
        """
        Delete infra segment

        :type  segment_id: :class:`str`
        :param segment_id: Segment ID (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete', {'segment_id': segment_id})

    def delete_0(self, segment_id):
        """
        Force delete bypasses validations during segment deletion. This may
        result in an inconsistent connectivity.

        :type  segment_id: :class:`str`
        :param segment_id: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete_0', {'segment_id': segment_id})

    def get(self, segment_id):
        """
        Read infra segment

        :type  segment_id: :class:`str`
        :param segment_id: Segment ID (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.Segment`
        :return: com.vmware.nsx_policy.model.Segment
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'segment_id': segment_id})

    def list(self, cursor=None, include_mark_for_delete_objects=None,
        included_fields=None, page_size=None, sort_ascending=None, sort_by=None
        ):
        """
        Paginated list of all segments under infra.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.SegmentListResult`
        :return: com.vmware.nsx_policy.model.SegmentListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'cursor': cursor,
            'include_mark_for_delete_objects':
            include_mark_for_delete_objects, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})

    def patch(self, segment_id, segment):
        """
        If segment with the segment-id is not already present, create a new
        segment. If it already exists, update the segment with specified
        attributes.

        :type  segment_id: :class:`str`
        :param segment_id: Segment ID (required)
        :type  segment: :class:`com.vmware.nsx_policy.model_client.Segment`
        :param segment: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch', {'segment_id': segment_id, 'segment':
            segment})

    def update(self, segment_id, segment):
        """
        If segment with the segment-id is not already present, create a new
        segment. If it already exists, replace the segment with this object.

        :type  segment_id: :class:`str`
        :param segment_id: Segment ID (required)
        :type  segment: :class:`com.vmware.nsx_policy.model_client.Segment`
        :param segment: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.Segment`
        :return: com.vmware.nsx_policy.model.Segment
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update', {'segment_id': segment_id, 'segment':
            segment})


class Services(VapiInterface):
    """
    
    """
    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.services'
    """
    Identifier of the service in canonical form.
    """

    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _ServicesStub)
        self._VAPI_OPERATION_IDS = {}

    def delete(self, service_id):
        """
        Delete Service

        :type  service_id: :class:`str`
        :param service_id: Service ID (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete', {'service_id': service_id})

    def get(self, service_id):
        """
        Read a service

        :type  service_id: :class:`str`
        :param service_id: Service ID (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.Service`
        :return: com.vmware.nsx_policy.model.Service
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get', {'service_id': service_id})

    def list(self, cursor=None, default_service=None,
        include_mark_for_delete_objects=None, included_fields=None,
        page_size=None, sort_ascending=None, sort_by=None):
        """
        Paginated list of Services for infra.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  default_service: :class:`bool` or ``None``
        :param default_service: Fetch all default services (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.ServiceListResult`
        :return: com.vmware.nsx_policy.model.ServiceListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list', {'cursor': cursor, 'default_service':
            default_service, 'include_mark_for_delete_objects':
            include_mark_for_delete_objects, 'included_fields':
            included_fields, 'page_size': page_size, 'sort_ascending':
            sort_ascending, 'sort_by': sort_by})

    def patch(self, service_id, service):
        """
        Create a new service if a service with the given ID does not already
        exist. Creates new service entries if populated in the service. If a
        service with the given ID already exists, patch the service including
        the nested service entries.

        :type  service_id: :class:`str`
        :param service_id: Service ID (required)
        :type  service: :class:`com.vmware.nsx_policy.model_client.Service`
        :param service: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch', {'service_id': service_id, 'service':
            service})

    def update(self, service_id, service):
        """
        Create a new service if a service with the given ID does not already
        exist. Creates new service entries if populated in the service. If a
        service with the given ID already exists, update the service including
        the nested service entries. This is a full replace.

        :type  service_id: :class:`str`
        :param service_id: Service ID (required)
        :type  service: :class:`com.vmware.nsx_policy.model_client.Service`
        :param service: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.Service`
        :return: com.vmware.nsx_policy.model.Service
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update', {'service_id': service_id, 'service':
            service})


class _DhcpRelayConfigsStub(ApiInterfaceStub):

    def __init__(self, config):
        delete_input_type = type.StructType('operation-input', {
            'dhcp_relay_config_id': type.StringType()})
        delete_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template=
            '/policy/api/v1/infra/dhcp-relay-configs/{dhcp-relay-config-id}',
            path_variables={'dhcp_relay_config_id': 'dhcp-relay-config-id'},
            query_parameters={}, content_type='application/json')
        get_input_type = type.StructType('operation-input', {
            'dhcp_relay_config_id': type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template=
            '/policy/api/v1/infra/dhcp-relay-configs/{dhcp-relay-config-id}',
            path_variables={'dhcp_relay_config_id': 'dhcp-relay-config-id'},
            query_parameters={}, content_type='application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/dhcp-relay-configs',
            path_variables={}, query_parameters={'cursor': 'cursor',
            'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        patch_input_type = type.StructType('operation-input', {
            'dhcp_relay_config_id': type.StringType(), 'dhcp_relay_config':
            type.ReferenceType('com.vmware.nsx_policy.model_client',
            'DhcpRelayConfig')})
        patch_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        patch_input_value_validator_list = [HasFieldsOfValidator()]
        patch_output_validator_list = []
        patch_rest_metadata = OperationRestMetadata(http_method='PATCH',
            url_template=
            '/policy/api/v1/infra/dhcp-relay-configs/{dhcp-relay-config-id}',
            request_body_parameter='dhcp_relay_config', path_variables={
            'dhcp_relay_config_id': 'dhcp-relay-config-id'},
            query_parameters={}, content_type='application/json')
        update_input_type = type.StructType('operation-input', {
            'dhcp_relay_config_id': type.StringType(), 'dhcp_relay_config':
            type.ReferenceType('com.vmware.nsx_policy.model_client',
            'DhcpRelayConfig')})
        update_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(http_method='PUT',
            url_template=
            '/policy/api/v1/infra/dhcp-relay-configs/{dhcp-relay-config-id}',
            request_body_parameter='dhcp_relay_config', path_variables={
            'dhcp_relay_config_id': 'dhcp-relay-config-id'},
            query_parameters={}, content_type='application/json')
        operations = {'delete': {'input_type': delete_input_type,
            'output_type': type.VoidType(), 'errors': delete_error_dict,
            'input_value_validator_list': delete_input_value_validator_list,
            'output_validator_list': delete_output_validator_list,
            'task_type': TaskType.NONE}, 'get': {'input_type':
            get_input_type, 'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'DhcpRelayConfig'),
            'errors': get_error_dict, 'input_value_validator_list':
            get_input_value_validator_list, 'output_validator_list':
            get_output_validator_list, 'task_type': TaskType.NONE}, 'list':
            {'input_type': list_input_type, 'output_type': type.
            ReferenceType('com.vmware.nsx_policy.model_client',
            'DhcpRelayConfigListResult'), 'errors': list_error_dict,
            'input_value_validator_list': list_input_value_validator_list,
            'output_validator_list': list_output_validator_list,
            'task_type': TaskType.NONE}, 'patch': {'input_type':
            patch_input_type, 'output_type': type.VoidType(), 'errors':
            patch_error_dict, 'input_value_validator_list':
            patch_input_value_validator_list, 'output_validator_list':
            patch_output_validator_list, 'task_type': TaskType.NONE},
            'update': {'input_type': update_input_type, 'output_type': type
            .ReferenceType('com.vmware.nsx_policy.model_client',
            'DhcpRelayConfig'), 'errors': update_error_dict,
            'input_value_validator_list': update_input_value_validator_list,
            'output_validator_list': update_output_validator_list,
            'task_type': TaskType.NONE}}
        rest_metadata = {'delete': delete_rest_metadata, 'get':
            get_rest_metadata, 'list': list_rest_metadata, 'patch':
            patch_rest_metadata, 'update': update_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.dhcp_relay_configs', config=config,
            operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)


class _DhcpServerConfigsStub(ApiInterfaceStub):

    def __init__(self, config):
        delete_input_type = type.StructType('operation-input', {
            'dhcp_server_config_id': type.StringType()})
        delete_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template=
            '/policy/api/v1/infra/dhcp-server-configs/{dhcp-server-config-id}',
            path_variables={'dhcp_server_config_id':
            'dhcp-server-config-id'}, query_parameters={}, content_type=
            'application/json')
        get_input_type = type.StructType('operation-input', {
            'dhcp_server_config_id': type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template=
            '/policy/api/v1/infra/dhcp-server-configs/{dhcp-server-config-id}',
            path_variables={'dhcp_server_config_id':
            'dhcp-server-config-id'}, query_parameters={}, content_type=
            'application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/dhcp-server-configs',
            path_variables={}, query_parameters={'cursor': 'cursor',
            'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        patch_input_type = type.StructType('operation-input', {
            'dhcp_server_config_id': type.StringType(),
            'dhcp_server_config': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'DhcpServerConfig')})
        patch_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        patch_input_value_validator_list = [HasFieldsOfValidator()]
        patch_output_validator_list = []
        patch_rest_metadata = OperationRestMetadata(http_method='PATCH',
            url_template=
            '/policy/api/v1/infra/dhcp-server-configs/{dhcp-server-config-id}',
            request_body_parameter='dhcp_server_config', path_variables={
            'dhcp_server_config_id': 'dhcp-server-config-id'},
            query_parameters={}, content_type='application/json')
        update_input_type = type.StructType('operation-input', {
            'dhcp_server_config_id': type.StringType(),
            'dhcp_server_config': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'DhcpServerConfig')})
        update_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(http_method='PUT',
            url_template=
            '/policy/api/v1/infra/dhcp-server-configs/{dhcp-server-config-id}',
            request_body_parameter='dhcp_server_config', path_variables={
            'dhcp_server_config_id': 'dhcp-server-config-id'},
            query_parameters={}, content_type='application/json')
        operations = {'delete': {'input_type': delete_input_type,
            'output_type': type.VoidType(), 'errors': delete_error_dict,
            'input_value_validator_list': delete_input_value_validator_list,
            'output_validator_list': delete_output_validator_list,
            'task_type': TaskType.NONE}, 'get': {'input_type':
            get_input_type, 'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'DhcpServerConfig'),
            'errors': get_error_dict, 'input_value_validator_list':
            get_input_value_validator_list, 'output_validator_list':
            get_output_validator_list, 'task_type': TaskType.NONE}, 'list':
            {'input_type': list_input_type, 'output_type': type.
            ReferenceType('com.vmware.nsx_policy.model_client',
            'DhcpServerConfigListResult'), 'errors': list_error_dict,
            'input_value_validator_list': list_input_value_validator_list,
            'output_validator_list': list_output_validator_list,
            'task_type': TaskType.NONE}, 'patch': {'input_type':
            patch_input_type, 'output_type': type.VoidType(), 'errors':
            patch_error_dict, 'input_value_validator_list':
            patch_input_value_validator_list, 'output_validator_list':
            patch_output_validator_list, 'task_type': TaskType.NONE},
            'update': {'input_type': update_input_type, 'output_type': type
            .ReferenceType('com.vmware.nsx_policy.model_client',
            'DhcpServerConfig'), 'errors': update_error_dict,
            'input_value_validator_list': update_input_value_validator_list,
            'output_validator_list': update_output_validator_list,
            'task_type': TaskType.NONE}}
        rest_metadata = {'delete': delete_rest_metadata, 'get':
            get_rest_metadata, 'list': list_rest_metadata, 'patch':
            patch_rest_metadata, 'update': update_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.dhcp_server_configs', config=
            config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)


class _DnsForwarderZonesStub(ApiInterfaceStub):

    def __init__(self, config):
        delete_input_type = type.StructType('operation-input', {
            'dns_forwarder_zone_id': type.StringType()})
        delete_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template=
            '/policy/api/v1/infra/dns-forwarder-zones/{dns-forwarder-zone-id}',
            path_variables={'dns_forwarder_zone_id':
            'dns-forwarder-zone-id'}, query_parameters={}, content_type=
            'application/json')
        get_input_type = type.StructType('operation-input', {
            'dns_forwarder_zone_id': type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template=
            '/policy/api/v1/infra/dns-forwarder-zones/{dns-forwarder-zone-id}',
            path_variables={'dns_forwarder_zone_id':
            'dns-forwarder-zone-id'}, query_parameters={}, content_type=
            'application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/dns-forwarder-zones',
            path_variables={}, query_parameters={'cursor': 'cursor',
            'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        patch_input_type = type.StructType('operation-input', {
            'dns_forwarder_zone_id': type.StringType(),
            'policy_dns_forwarder_zone': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'PolicyDnsForwarderZone')})
        patch_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        patch_input_value_validator_list = [HasFieldsOfValidator()]
        patch_output_validator_list = []
        patch_rest_metadata = OperationRestMetadata(http_method='PATCH',
            url_template=
            '/policy/api/v1/infra/dns-forwarder-zones/{dns-forwarder-zone-id}',
            request_body_parameter='policy_dns_forwarder_zone',
            path_variables={'dns_forwarder_zone_id':
            'dns-forwarder-zone-id'}, query_parameters={}, content_type=
            'application/json')
        update_input_type = type.StructType('operation-input', {
            'dns_forwarder_zone_id': type.StringType(),
            'policy_dns_forwarder_zone': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'PolicyDnsForwarderZone')})
        update_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(http_method='PUT',
            url_template=
            '/policy/api/v1/infra/dns-forwarder-zones/{dns-forwarder-zone-id}',
            request_body_parameter='policy_dns_forwarder_zone',
            path_variables={'dns_forwarder_zone_id':
            'dns-forwarder-zone-id'}, query_parameters={}, content_type=
            'application/json')
        operations = {'delete': {'input_type': delete_input_type,
            'output_type': type.VoidType(), 'errors': delete_error_dict,
            'input_value_validator_list': delete_input_value_validator_list,
            'output_validator_list': delete_output_validator_list,
            'task_type': TaskType.NONE}, 'get': {'input_type':
            get_input_type, 'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'PolicyDnsForwarderZone'),
            'errors': get_error_dict, 'input_value_validator_list':
            get_input_value_validator_list, 'output_validator_list':
            get_output_validator_list, 'task_type': TaskType.NONE}, 'list':
            {'input_type': list_input_type, 'output_type': type.
            ReferenceType('com.vmware.nsx_policy.model_client',
            'PolicyDnsForwarderZoneListResult'), 'errors': list_error_dict,
            'input_value_validator_list': list_input_value_validator_list,
            'output_validator_list': list_output_validator_list,
            'task_type': TaskType.NONE}, 'patch': {'input_type':
            patch_input_type, 'output_type': type.VoidType(), 'errors':
            patch_error_dict, 'input_value_validator_list':
            patch_input_value_validator_list, 'output_validator_list':
            patch_output_validator_list, 'task_type': TaskType.NONE},
            'update': {'input_type': update_input_type, 'output_type': type
            .ReferenceType('com.vmware.nsx_policy.model_client',
            'PolicyDnsForwarderZone'), 'errors': update_error_dict,
            'input_value_validator_list': update_input_value_validator_list,
            'output_validator_list': update_output_validator_list,
            'task_type': TaskType.NONE}}
        rest_metadata = {'delete': delete_rest_metadata, 'get':
            get_rest_metadata, 'list': list_rest_metadata, 'patch':
            patch_rest_metadata, 'update': update_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.dns_forwarder_zones', config=
            config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)


class _DomainsStub(ApiInterfaceStub):

    def __init__(self, config):
        get_input_type = type.StructType('operation-input', {'domain_id':
            type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/domains/{domain-id}',
            path_variables={'domain_id': 'domain-id'}, query_parameters={},
            content_type='application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/domains', path_variables={},
            query_parameters={'cursor': 'cursor',
            'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        operations = {'get': {'input_type': get_input_type, 'output_type':
            type.ReferenceType('com.vmware.nsx_policy.model_client',
            'Domain'), 'errors': get_error_dict,
            'input_value_validator_list': get_input_value_validator_list,
            'output_validator_list': get_output_validator_list, 'task_type':
            TaskType.NONE}, 'list': {'input_type': list_input_type,
            'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'DomainListResult'),
            'errors': list_error_dict, 'input_value_validator_list':
            list_input_value_validator_list, 'output_validator_list':
            list_output_validator_list, 'task_type': TaskType.NONE}}
        rest_metadata = {'get': get_rest_metadata, 'list': list_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.domains', config=config,
            operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)


class _DraftsStub(ApiInterfaceStub):

    def __init__(self, config):
        abort_input_type = type.StructType('operation-input', {'draft_id':
            type.StringType()})
        abort_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        abort_input_value_validator_list = []
        abort_output_validator_list = []
        abort_rest_metadata = OperationRestMetadata(http_method='POST',
            url_template=
            '/policy/api/v1/infra/drafts/{draft-id}?action=abort',
            path_variables={'draft_id': 'draft-id'}, query_parameters={},
            content_type='application/json')
        delete_input_type = type.StructType('operation-input', {'draft_id':
            type.StringType()})
        delete_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template='/policy/api/v1/infra/drafts/{draft-id}',
            path_variables={'draft_id': 'draft-id'}, query_parameters={},
            content_type='application/json')
        get_input_type = type.StructType('operation-input', {'draft_id':
            type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/drafts/{draft-id}',
            path_variables={'draft_id': 'draft-id'}, query_parameters={},
            content_type='application/json')
        list_input_type = type.StructType('operation-input', {'auto_drafts':
            type.OptionalType(type.BooleanType()), 'cursor': type.
            OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/drafts', path_variables={},
            query_parameters={'auto_drafts': 'auto_drafts', 'cursor':
            'cursor', 'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        patch_input_type = type.StructType('operation-input', {'draft_id':
            type.StringType(), 'policy_draft': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'PolicyDraft')})
        patch_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        patch_input_value_validator_list = [HasFieldsOfValidator()]
        patch_output_validator_list = []
        patch_rest_metadata = OperationRestMetadata(http_method='PATCH',
            url_template='/policy/api/v1/infra/drafts/{draft-id}',
            request_body_parameter='policy_draft', path_variables={
            'draft_id': 'draft-id'}, query_parameters={}, content_type=
            'application/json')
        publish_input_type = type.StructType('operation-input', {'draft_id':
            type.StringType(), 'infra': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'Infra')})
        publish_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        publish_input_value_validator_list = [HasFieldsOfValidator()]
        publish_output_validator_list = []
        publish_rest_metadata = OperationRestMetadata(http_method='POST',
            url_template=
            '/policy/api/v1/infra/drafts/{draft-id}?action=publish',
            request_body_parameter='infra', path_variables={'draft_id':
            'draft-id'}, query_parameters={}, content_type='application/json')
        update_input_type = type.StructType('operation-input', {'draft_id':
            type.StringType(), 'policy_draft': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'PolicyDraft')})
        update_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(http_method='PUT',
            url_template='/policy/api/v1/infra/drafts/{draft-id}',
            request_body_parameter='policy_draft', path_variables={
            'draft_id': 'draft-id'}, query_parameters={}, content_type=
            'application/json')
        operations = {'abort': {'input_type': abort_input_type,
            'output_type': type.VoidType(), 'errors': abort_error_dict,
            'input_value_validator_list': abort_input_value_validator_list,
            'output_validator_list': abort_output_validator_list,
            'task_type': TaskType.NONE}, 'delete': {'input_type':
            delete_input_type, 'output_type': type.VoidType(), 'errors':
            delete_error_dict, 'input_value_validator_list':
            delete_input_value_validator_list, 'output_validator_list':
            delete_output_validator_list, 'task_type': TaskType.NONE},
            'get': {'input_type': get_input_type, 'output_type': type.
            ReferenceType('com.vmware.nsx_policy.model_client',
            'PolicyDraft'), 'errors': get_error_dict,
            'input_value_validator_list': get_input_value_validator_list,
            'output_validator_list': get_output_validator_list, 'task_type':
            TaskType.NONE}, 'list': {'input_type': list_input_type,
            'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'PolicyDraftListResult'),
            'errors': list_error_dict, 'input_value_validator_list':
            list_input_value_validator_list, 'output_validator_list':
            list_output_validator_list, 'task_type': TaskType.NONE},
            'patch': {'input_type': patch_input_type, 'output_type': type.
            VoidType(), 'errors': patch_error_dict,
            'input_value_validator_list': patch_input_value_validator_list,
            'output_validator_list': patch_output_validator_list,
            'task_type': TaskType.NONE}, 'publish': {'input_type':
            publish_input_type, 'output_type': type.VoidType(), 'errors':
            publish_error_dict, 'input_value_validator_list':
            publish_input_value_validator_list, 'output_validator_list':
            publish_output_validator_list, 'task_type': TaskType.NONE},
            'update': {'input_type': update_input_type, 'output_type': type
            .ReferenceType('com.vmware.nsx_policy.model_client',
            'PolicyDraft'), 'errors': update_error_dict,
            'input_value_validator_list': update_input_value_validator_list,
            'output_validator_list': update_output_validator_list,
            'task_type': TaskType.NONE}}
        rest_metadata = {'abort': abort_rest_metadata, 'delete':
            delete_rest_metadata, 'get': get_rest_metadata, 'list':
            list_rest_metadata, 'patch': patch_rest_metadata, 'publish':
            publish_rest_metadata, 'update': update_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.drafts', config=config, operations
            =operations, rest_metadata=rest_metadata, is_vapi_rest=False)


class _GroupAssociationsStub(ApiInterfaceStub):

    def __init__(self, config):
        list_input_type = type.StructType('operation-input', {'intent_path':
            type.StringType(), 'cursor': type.OptionalType(type.StringType(
            )), 'enforcement_point_path': type.OptionalType(type.StringType
            ()), 'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = []
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/group-associations',
            path_variables={}, query_parameters={'intent_path':
            'intent_path', 'cursor': 'cursor', 'enforcement_point_path':
            'enforcement_point_path', 'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        operations = {'list': {'input_type': list_input_type, 'output_type':
            type.ReferenceType('com.vmware.nsx_policy.model_client',
            'PolicyResourceReferenceForEPListResult'), 'errors':
            list_error_dict, 'input_value_validator_list':
            list_input_value_validator_list, 'output_validator_list':
            list_output_validator_list, 'task_type': TaskType.NONE}}
        rest_metadata = {'list': list_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.group_associations', config=config,
            operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)


class _IpfixCollectorProfilesStub(ApiInterfaceStub):

    def __init__(self, config):
        delete_input_type = type.StructType('operation-input', {
            'ipfix_collector_profile_id': type.StringType()})
        delete_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template=
            '/policy/api/v1/infra/ipfix-collector-profiles/{ipfix-collector-profile-id}'
            , path_variables={'ipfix_collector_profile_id':
            'ipfix-collector-profile-id'}, query_parameters={},
            content_type='application/json')
        get_input_type = type.StructType('operation-input', {
            'ipfix_collector_profile_id': type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template=
            '/policy/api/v1/infra/ipfix-collector-profiles/{ipfix-collector-profile-id}'
            , path_variables={'ipfix_collector_profile_id':
            'ipfix-collector-profile-id'}, query_parameters={},
            content_type='application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/ipfix-collector-profiles',
            path_variables={}, query_parameters={'cursor': 'cursor',
            'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        patch_input_type = type.StructType('operation-input', {
            'ipfix_collector_profile_id': type.StringType(),
            'i_PFIX_collector_profile': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'IPFIXCollectorProfile')})
        patch_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        patch_input_value_validator_list = [HasFieldsOfValidator()]
        patch_output_validator_list = []
        patch_rest_metadata = OperationRestMetadata(http_method='PATCH',
            url_template=
            '/policy/api/v1/infra/ipfix-collector-profiles/{ipfix-collector-profile-id}'
            , request_body_parameter='i_PFIX_collector_profile',
            path_variables={'ipfix_collector_profile_id':
            'ipfix-collector-profile-id'}, query_parameters={},
            content_type='application/json')
        update_input_type = type.StructType('operation-input', {
            'ipfix_collector_profile_id': type.StringType(),
            'i_PFIX_collector_profile': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'IPFIXCollectorProfile')})
        update_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(http_method='PUT',
            url_template=
            '/policy/api/v1/infra/ipfix-collector-profiles/{ipfix-collector-profile-id}'
            , request_body_parameter='i_PFIX_collector_profile',
            path_variables={'ipfix_collector_profile_id':
            'ipfix-collector-profile-id'}, query_parameters={},
            content_type='application/json')
        operations = {'delete': {'input_type': delete_input_type,
            'output_type': type.VoidType(), 'errors': delete_error_dict,
            'input_value_validator_list': delete_input_value_validator_list,
            'output_validator_list': delete_output_validator_list,
            'task_type': TaskType.NONE}, 'get': {'input_type':
            get_input_type, 'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'IPFIXCollectorProfile'),
            'errors': get_error_dict, 'input_value_validator_list':
            get_input_value_validator_list, 'output_validator_list':
            get_output_validator_list, 'task_type': TaskType.NONE}, 'list':
            {'input_type': list_input_type, 'output_type': type.
            ReferenceType('com.vmware.nsx_policy.model_client',
            'IPFIXCollectorProfileListResult'), 'errors': list_error_dict,
            'input_value_validator_list': list_input_value_validator_list,
            'output_validator_list': list_output_validator_list,
            'task_type': TaskType.NONE}, 'patch': {'input_type':
            patch_input_type, 'output_type': type.VoidType(), 'errors':
            patch_error_dict, 'input_value_validator_list':
            patch_input_value_validator_list, 'output_validator_list':
            patch_output_validator_list, 'task_type': TaskType.NONE},
            'update': {'input_type': update_input_type, 'output_type': type
            .ReferenceType('com.vmware.nsx_policy.model_client',
            'IPFIXCollectorProfile'), 'errors': update_error_dict,
            'input_value_validator_list': update_input_value_validator_list,
            'output_validator_list': update_output_validator_list,
            'task_type': TaskType.NONE}}
        rest_metadata = {'delete': delete_rest_metadata, 'get':
            get_rest_metadata, 'list': list_rest_metadata, 'patch':
            patch_rest_metadata, 'update': update_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.ipfix_collector_profiles', config=
            config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)


class _IpfixDfwCollectorProfilesStub(ApiInterfaceStub):

    def __init__(self, config):
        delete_input_type = type.StructType('operation-input', {
            'ipfix_dfw_collector_profile_id': type.StringType()})
        delete_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template=
            '/policy/api/v1/infra/ipfix-dfw-collector-profiles/{ipfix-dfw-collector-profile-id}'
            , path_variables={'ipfix_dfw_collector_profile_id':
            'ipfix-dfw-collector-profile-id'}, query_parameters={},
            content_type='application/json')
        get_input_type = type.StructType('operation-input', {
            'ipfix_dfw_collector_profile_id': type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template=
            '/policy/api/v1/infra/ipfix-dfw-collector-profiles/{ipfix-dfw-collector-profile-id}'
            , path_variables={'ipfix_dfw_collector_profile_id':
            'ipfix-dfw-collector-profile-id'}, query_parameters={},
            content_type='application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template=
            '/policy/api/v1/infra/ipfix-dfw-collector-profiles',
            path_variables={}, query_parameters={'cursor': 'cursor',
            'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        patch_input_type = type.StructType('operation-input', {
            'ipfix_dfw_collector_profile_id': type.StringType(),
            'i_PFIXDFW_collector_profile': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'IPFIXDFWCollectorProfile')})
        patch_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        patch_input_value_validator_list = [HasFieldsOfValidator()]
        patch_output_validator_list = []
        patch_rest_metadata = OperationRestMetadata(http_method='PATCH',
            url_template=
            '/policy/api/v1/infra/ipfix-dfw-collector-profiles/{ipfix-dfw-collector-profile-id}'
            , request_body_parameter='i_PFIXDFW_collector_profile',
            path_variables={'ipfix_dfw_collector_profile_id':
            'ipfix-dfw-collector-profile-id'}, query_parameters={},
            content_type='application/json')
        update_input_type = type.StructType('operation-input', {
            'ipfix_dfw_collector_profile_id': type.StringType(),
            'i_PFIXDFW_collector_profile': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'IPFIXDFWCollectorProfile')})
        update_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(http_method='PUT',
            url_template=
            '/policy/api/v1/infra/ipfix-dfw-collector-profiles/{ipfix-dfw-collector-profile-id}'
            , request_body_parameter='i_PFIXDFW_collector_profile',
            path_variables={'ipfix_dfw_collector_profile_id':
            'ipfix-dfw-collector-profile-id'}, query_parameters={},
            content_type='application/json')
        operations = {'delete': {'input_type': delete_input_type,
            'output_type': type.VoidType(), 'errors': delete_error_dict,
            'input_value_validator_list': delete_input_value_validator_list,
            'output_validator_list': delete_output_validator_list,
            'task_type': TaskType.NONE}, 'get': {'input_type':
            get_input_type, 'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client',
            'IPFIXDFWCollectorProfile'), 'errors': get_error_dict,
            'input_value_validator_list': get_input_value_validator_list,
            'output_validator_list': get_output_validator_list, 'task_type':
            TaskType.NONE}, 'list': {'input_type': list_input_type,
            'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client',
            'IPFIXDFWCollectorProfileListResult'), 'errors':
            list_error_dict, 'input_value_validator_list':
            list_input_value_validator_list, 'output_validator_list':
            list_output_validator_list, 'task_type': TaskType.NONE},
            'patch': {'input_type': patch_input_type, 'output_type': type.
            VoidType(), 'errors': patch_error_dict,
            'input_value_validator_list': patch_input_value_validator_list,
            'output_validator_list': patch_output_validator_list,
            'task_type': TaskType.NONE}, 'update': {'input_type':
            update_input_type, 'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client',
            'IPFIXDFWCollectorProfile'), 'errors': update_error_dict,
            'input_value_validator_list': update_input_value_validator_list,
            'output_validator_list': update_output_validator_list,
            'task_type': TaskType.NONE}}
        rest_metadata = {'delete': delete_rest_metadata, 'get':
            get_rest_metadata, 'list': list_rest_metadata, 'patch':
            patch_rest_metadata, 'update': update_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.ipfix_dfw_collector_profiles',
            config=config, operations=operations, rest_metadata=
            rest_metadata, is_vapi_rest=False)


class _IpfixDfwProfilesStub(ApiInterfaceStub):

    def __init__(self, config):
        delete_input_type = type.StructType('operation-input', {
            'ipfix_dfw_profile_id': type.StringType()})
        delete_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template=
            '/policy/api/v1/infra/ipfix-dfw-profiles/{ipfix-dfw-profile-id}',
            path_variables={'ipfix_dfw_profile_id': 'ipfix-dfw-profile-id'},
            query_parameters={}, content_type='application/json')
        get_input_type = type.StructType('operation-input', {
            'ipfix_dfw_profile_id': type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template=
            '/policy/api/v1/infra/ipfix-dfw-profiles/{ipfix-dfw-profile-id}',
            path_variables={'ipfix_dfw_profile_id': 'ipfix-dfw-profile-id'},
            query_parameters={}, content_type='application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/ipfix-dfw-profiles',
            path_variables={}, query_parameters={'cursor': 'cursor',
            'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        patch_input_type = type.StructType('operation-input', {
            'ipfix_dfw_profile_id': type.StringType(), 'i_PFIXDFW_profile':
            type.ReferenceType('com.vmware.nsx_policy.model_client',
            'IPFIXDFWProfile')})
        patch_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        patch_input_value_validator_list = [HasFieldsOfValidator()]
        patch_output_validator_list = []
        patch_rest_metadata = OperationRestMetadata(http_method='PATCH',
            url_template=
            '/policy/api/v1/infra/ipfix-dfw-profiles/{ipfix-dfw-profile-id}',
            request_body_parameter='i_PFIXDFW_profile', path_variables={
            'ipfix_dfw_profile_id': 'ipfix-dfw-profile-id'},
            query_parameters={}, content_type='application/json')
        update_input_type = type.StructType('operation-input', {
            'ipfix_dfw_profile_id': type.StringType(), 'i_PFIXDFW_profile':
            type.ReferenceType('com.vmware.nsx_policy.model_client',
            'IPFIXDFWProfile')})
        update_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(http_method='PUT',
            url_template=
            '/policy/api/v1/infra/ipfix-dfw-profiles/{ipfix-dfw-profile-id}',
            request_body_parameter='i_PFIXDFW_profile', path_variables={
            'ipfix_dfw_profile_id': 'ipfix-dfw-profile-id'},
            query_parameters={}, content_type='application/json')
        operations = {'delete': {'input_type': delete_input_type,
            'output_type': type.VoidType(), 'errors': delete_error_dict,
            'input_value_validator_list': delete_input_value_validator_list,
            'output_validator_list': delete_output_validator_list,
            'task_type': TaskType.NONE}, 'get': {'input_type':
            get_input_type, 'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'IPFIXDFWProfile'),
            'errors': get_error_dict, 'input_value_validator_list':
            get_input_value_validator_list, 'output_validator_list':
            get_output_validator_list, 'task_type': TaskType.NONE}, 'list':
            {'input_type': list_input_type, 'output_type': type.
            ReferenceType('com.vmware.nsx_policy.model_client',
            'IPFIXDFWProfileListResult'), 'errors': list_error_dict,
            'input_value_validator_list': list_input_value_validator_list,
            'output_validator_list': list_output_validator_list,
            'task_type': TaskType.NONE}, 'patch': {'input_type':
            patch_input_type, 'output_type': type.VoidType(), 'errors':
            patch_error_dict, 'input_value_validator_list':
            patch_input_value_validator_list, 'output_validator_list':
            patch_output_validator_list, 'task_type': TaskType.NONE},
            'update': {'input_type': update_input_type, 'output_type': type
            .ReferenceType('com.vmware.nsx_policy.model_client',
            'IPFIXDFWProfile'), 'errors': update_error_dict,
            'input_value_validator_list': update_input_value_validator_list,
            'output_validator_list': update_output_validator_list,
            'task_type': TaskType.NONE}}
        rest_metadata = {'delete': delete_rest_metadata, 'get':
            get_rest_metadata, 'list': list_rest_metadata, 'patch':
            patch_rest_metadata, 'update': update_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.ipfix_dfw_profiles', config=config,
            operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)


class _IpfixL2CollectorProfilesStub(ApiInterfaceStub):

    def __init__(self, config):
        delete_input_type = type.StructType('operation-input', {
            'ipfix_l2_collector_profile_id': type.StringType()})
        delete_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template=
            '/policy/api/v1/infra/ipfix-l2-collector-profiles/{ipfix-l2-collector-profile-id}'
            , path_variables={'ipfix_l2_collector_profile_id':
            'ipfix-l2-collector-profile-id'}, query_parameters={},
            content_type='application/json')
        get_input_type = type.StructType('operation-input', {
            'ipfix_l2_collector_profile_id': type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template=
            '/policy/api/v1/infra/ipfix-l2-collector-profiles/{ipfix-l2-collector-profile-id}'
            , path_variables={'ipfix_l2_collector_profile_id':
            'ipfix-l2-collector-profile-id'}, query_parameters={},
            content_type='application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/ipfix-l2-collector-profiles',
            path_variables={}, query_parameters={'cursor': 'cursor',
            'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        patch_input_type = type.StructType('operation-input', {
            'ipfix_l2_collector_profile_id': type.StringType(),
            'i_PFIX_l2_collector_profile': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'IPFIXL2CollectorProfile')})
        patch_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        patch_input_value_validator_list = [HasFieldsOfValidator()]
        patch_output_validator_list = []
        patch_rest_metadata = OperationRestMetadata(http_method='PATCH',
            url_template=
            '/policy/api/v1/infra/ipfix-l2-collector-profiles/{ipfix-l2-collector-profile-id}'
            , request_body_parameter='i_PFIX_l2_collector_profile',
            path_variables={'ipfix_l2_collector_profile_id':
            'ipfix-l2-collector-profile-id'}, query_parameters={},
            content_type='application/json')
        update_input_type = type.StructType('operation-input', {
            'ipfix_l2_collector_profile_id': type.StringType(),
            'i_PFIX_l2_collector_profile': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'IPFIXL2CollectorProfile')})
        update_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(http_method='PUT',
            url_template=
            '/policy/api/v1/infra/ipfix-l2-collector-profiles/{ipfix-l2-collector-profile-id}'
            , request_body_parameter='i_PFIX_l2_collector_profile',
            path_variables={'ipfix_l2_collector_profile_id':
            'ipfix-l2-collector-profile-id'}, query_parameters={},
            content_type='application/json')
        operations = {'delete': {'input_type': delete_input_type,
            'output_type': type.VoidType(), 'errors': delete_error_dict,
            'input_value_validator_list': delete_input_value_validator_list,
            'output_validator_list': delete_output_validator_list,
            'task_type': TaskType.NONE}, 'get': {'input_type':
            get_input_type, 'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'IPFIXL2CollectorProfile'
            ), 'errors': get_error_dict, 'input_value_validator_list':
            get_input_value_validator_list, 'output_validator_list':
            get_output_validator_list, 'task_type': TaskType.NONE}, 'list':
            {'input_type': list_input_type, 'output_type': type.
            ReferenceType('com.vmware.nsx_policy.model_client',
            'IPFIXL2CollectorProfileListResult'), 'errors': list_error_dict,
            'input_value_validator_list': list_input_value_validator_list,
            'output_validator_list': list_output_validator_list,
            'task_type': TaskType.NONE}, 'patch': {'input_type':
            patch_input_type, 'output_type': type.VoidType(), 'errors':
            patch_error_dict, 'input_value_validator_list':
            patch_input_value_validator_list, 'output_validator_list':
            patch_output_validator_list, 'task_type': TaskType.NONE},
            'update': {'input_type': update_input_type, 'output_type': type
            .ReferenceType('com.vmware.nsx_policy.model_client',
            'IPFIXL2CollectorProfile'), 'errors': update_error_dict,
            'input_value_validator_list': update_input_value_validator_list,
            'output_validator_list': update_output_validator_list,
            'task_type': TaskType.NONE}}
        rest_metadata = {'delete': delete_rest_metadata, 'get':
            get_rest_metadata, 'list': list_rest_metadata, 'patch':
            patch_rest_metadata, 'update': update_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.ipfix_l2_collector_profiles',
            config=config, operations=operations, rest_metadata=
            rest_metadata, is_vapi_rest=False)


class _IpfixL2ProfilesStub(ApiInterfaceStub):

    def __init__(self, config):
        delete_input_type = type.StructType('operation-input', {
            'ipfix_l2_profile_id': type.StringType()})
        delete_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template=
            '/policy/api/v1/infra/ipfix-l2-profiles/{ipfix-l2-profile-id}',
            path_variables={'ipfix_l2_profile_id': 'ipfix-l2-profile-id'},
            query_parameters={}, content_type='application/json')
        get_input_type = type.StructType('operation-input', {
            'ipfix_l2_profile_id': type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template=
            '/policy/api/v1/infra/ipfix-l2-profiles/{ipfix-l2-profile-id}',
            path_variables={'ipfix_l2_profile_id': 'ipfix-l2-profile-id'},
            query_parameters={}, content_type='application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/ipfix-l2-profiles',
            path_variables={}, query_parameters={'cursor': 'cursor',
            'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        patch_input_type = type.StructType('operation-input', {
            'ipfix_l2_profile_id': type.StringType(), 'i_PFIX_l2_profile':
            type.ReferenceType('com.vmware.nsx_policy.model_client',
            'IPFIXL2Profile')})
        patch_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        patch_input_value_validator_list = [HasFieldsOfValidator()]
        patch_output_validator_list = []
        patch_rest_metadata = OperationRestMetadata(http_method='PATCH',
            url_template=
            '/policy/api/v1/infra/ipfix-l2-profiles/{ipfix-l2-profile-id}',
            request_body_parameter='i_PFIX_l2_profile', path_variables={
            'ipfix_l2_profile_id': 'ipfix-l2-profile-id'}, query_parameters
            ={}, content_type='application/json')
        update_input_type = type.StructType('operation-input', {
            'ipfix_l2_profile_id': type.StringType(), 'i_PFIX_l2_profile':
            type.ReferenceType('com.vmware.nsx_policy.model_client',
            'IPFIXL2Profile')})
        update_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(http_method='PUT',
            url_template=
            '/policy/api/v1/infra/ipfix-l2-profiles/{ipfix-l2-profile-id}',
            request_body_parameter='i_PFIX_l2_profile', path_variables={
            'ipfix_l2_profile_id': 'ipfix-l2-profile-id'}, query_parameters
            ={}, content_type='application/json')
        operations = {'delete': {'input_type': delete_input_type,
            'output_type': type.VoidType(), 'errors': delete_error_dict,
            'input_value_validator_list': delete_input_value_validator_list,
            'output_validator_list': delete_output_validator_list,
            'task_type': TaskType.NONE}, 'get': {'input_type':
            get_input_type, 'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'IPFIXL2Profile'),
            'errors': get_error_dict, 'input_value_validator_list':
            get_input_value_validator_list, 'output_validator_list':
            get_output_validator_list, 'task_type': TaskType.NONE}, 'list':
            {'input_type': list_input_type, 'output_type': type.
            ReferenceType('com.vmware.nsx_policy.model_client',
            'IPFIXL2ProfileListResult'), 'errors': list_error_dict,
            'input_value_validator_list': list_input_value_validator_list,
            'output_validator_list': list_output_validator_list,
            'task_type': TaskType.NONE}, 'patch': {'input_type':
            patch_input_type, 'output_type': type.VoidType(), 'errors':
            patch_error_dict, 'input_value_validator_list':
            patch_input_value_validator_list, 'output_validator_list':
            patch_output_validator_list, 'task_type': TaskType.NONE},
            'update': {'input_type': update_input_type, 'output_type': type
            .ReferenceType('com.vmware.nsx_policy.model_client',
            'IPFIXL2Profile'), 'errors': update_error_dict,
            'input_value_validator_list': update_input_value_validator_list,
            'output_validator_list': update_output_validator_list,
            'task_type': TaskType.NONE}}
        rest_metadata = {'delete': delete_rest_metadata, 'get':
            get_rest_metadata, 'list': list_rest_metadata, 'patch':
            patch_rest_metadata, 'update': update_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.ipfix_l2_profiles', config=config,
            operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)


class _IpsecVpnDpdProfilesStub(ApiInterfaceStub):

    def __init__(self, config):
        delete_input_type = type.StructType('operation-input', {
            'dpd_profile_id': type.StringType()})
        delete_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template=
            '/policy/api/v1/infra/ipsec-vpn-dpd-profiles/{dpd-profile-id}',
            path_variables={'dpd_profile_id': 'dpd-profile-id'},
            query_parameters={}, content_type='application/json')
        get_input_type = type.StructType('operation-input', {
            'dpd_profile_id': type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template=
            '/policy/api/v1/infra/ipsec-vpn-dpd-profiles/{dpd-profile-id}',
            path_variables={'dpd_profile_id': 'dpd-profile-id'},
            query_parameters={}, content_type='application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/ipsec-vpn-dpd-profiles',
            path_variables={}, query_parameters={'cursor': 'cursor',
            'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        patch_input_type = type.StructType('operation-input', {
            'dpd_profile_id': type.StringType(), 'ip_sec_vpn_dpd_profile':
            type.ReferenceType('com.vmware.nsx_policy.model_client',
            'IPSecVpnDpdProfile')})
        patch_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        patch_input_value_validator_list = [HasFieldsOfValidator()]
        patch_output_validator_list = []
        patch_rest_metadata = OperationRestMetadata(http_method='PATCH',
            url_template=
            '/policy/api/v1/infra/ipsec-vpn-dpd-profiles/{dpd-profile-id}',
            request_body_parameter='ip_sec_vpn_dpd_profile', path_variables
            ={'dpd_profile_id': 'dpd-profile-id'}, query_parameters={},
            content_type='application/json')
        update_input_type = type.StructType('operation-input', {
            'dpd_profile_id': type.StringType(), 'ip_sec_vpn_dpd_profile':
            type.ReferenceType('com.vmware.nsx_policy.model_client',
            'IPSecVpnDpdProfile')})
        update_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(http_method='PUT',
            url_template=
            '/policy/api/v1/infra/ipsec-vpn-dpd-profiles/{dpd-profile-id}',
            request_body_parameter='ip_sec_vpn_dpd_profile', path_variables
            ={'dpd_profile_id': 'dpd-profile-id'}, query_parameters={},
            content_type='application/json')
        operations = {'delete': {'input_type': delete_input_type,
            'output_type': type.VoidType(), 'errors': delete_error_dict,
            'input_value_validator_list': delete_input_value_validator_list,
            'output_validator_list': delete_output_validator_list,
            'task_type': TaskType.NONE}, 'get': {'input_type':
            get_input_type, 'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'IPSecVpnDpdProfile'),
            'errors': get_error_dict, 'input_value_validator_list':
            get_input_value_validator_list, 'output_validator_list':
            get_output_validator_list, 'task_type': TaskType.NONE}, 'list':
            {'input_type': list_input_type, 'output_type': type.
            ReferenceType('com.vmware.nsx_policy.model_client',
            'IPSecVpnDpdProfileListResult'), 'errors': list_error_dict,
            'input_value_validator_list': list_input_value_validator_list,
            'output_validator_list': list_output_validator_list,
            'task_type': TaskType.NONE}, 'patch': {'input_type':
            patch_input_type, 'output_type': type.VoidType(), 'errors':
            patch_error_dict, 'input_value_validator_list':
            patch_input_value_validator_list, 'output_validator_list':
            patch_output_validator_list, 'task_type': TaskType.NONE},
            'update': {'input_type': update_input_type, 'output_type': type
            .ReferenceType('com.vmware.nsx_policy.model_client',
            'IPSecVpnDpdProfile'), 'errors': update_error_dict,
            'input_value_validator_list': update_input_value_validator_list,
            'output_validator_list': update_output_validator_list,
            'task_type': TaskType.NONE}}
        rest_metadata = {'delete': delete_rest_metadata, 'get':
            get_rest_metadata, 'list': list_rest_metadata, 'patch':
            patch_rest_metadata, 'update': update_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.ipsec_vpn_dpd_profiles', config=
            config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)


class _IpsecVpnIkeProfilesStub(ApiInterfaceStub):

    def __init__(self, config):
        delete_input_type = type.StructType('operation-input', {
            'ike_profile_id': type.StringType()})
        delete_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template=
            '/policy/api/v1/infra/ipsec-vpn-ike-profiles/{ike-profile-id}',
            path_variables={'ike_profile_id': 'ike-profile-id'},
            query_parameters={}, content_type='application/json')
        get_input_type = type.StructType('operation-input', {
            'ike_profile_id': type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template=
            '/policy/api/v1/infra/ipsec-vpn-ike-profiles/{ike-profile-id}',
            path_variables={'ike_profile_id': 'ike-profile-id'},
            query_parameters={}, content_type='application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/ipsec-vpn-ike-profiles',
            path_variables={}, query_parameters={'cursor': 'cursor',
            'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        patch_input_type = type.StructType('operation-input', {
            'ike_profile_id': type.StringType(), 'ip_sec_vpn_ike_profile':
            type.ReferenceType('com.vmware.nsx_policy.model_client',
            'IPSecVpnIkeProfile')})
        patch_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        patch_input_value_validator_list = [HasFieldsOfValidator()]
        patch_output_validator_list = []
        patch_rest_metadata = OperationRestMetadata(http_method='PATCH',
            url_template=
            '/policy/api/v1/infra/ipsec-vpn-ike-profiles/{ike-profile-id}',
            request_body_parameter='ip_sec_vpn_ike_profile', path_variables
            ={'ike_profile_id': 'ike-profile-id'}, query_parameters={},
            content_type='application/json')
        update_input_type = type.StructType('operation-input', {
            'ike_profile_id': type.StringType(), 'ip_sec_vpn_ike_profile':
            type.ReferenceType('com.vmware.nsx_policy.model_client',
            'IPSecVpnIkeProfile')})
        update_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(http_method='PUT',
            url_template=
            '/policy/api/v1/infra/ipsec-vpn-ike-profiles/{ike-profile-id}',
            request_body_parameter='ip_sec_vpn_ike_profile', path_variables
            ={'ike_profile_id': 'ike-profile-id'}, query_parameters={},
            content_type='application/json')
        operations = {'delete': {'input_type': delete_input_type,
            'output_type': type.VoidType(), 'errors': delete_error_dict,
            'input_value_validator_list': delete_input_value_validator_list,
            'output_validator_list': delete_output_validator_list,
            'task_type': TaskType.NONE}, 'get': {'input_type':
            get_input_type, 'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'IPSecVpnIkeProfile'),
            'errors': get_error_dict, 'input_value_validator_list':
            get_input_value_validator_list, 'output_validator_list':
            get_output_validator_list, 'task_type': TaskType.NONE}, 'list':
            {'input_type': list_input_type, 'output_type': type.
            ReferenceType('com.vmware.nsx_policy.model_client',
            'IPSecVpnIkeProfileListResult'), 'errors': list_error_dict,
            'input_value_validator_list': list_input_value_validator_list,
            'output_validator_list': list_output_validator_list,
            'task_type': TaskType.NONE}, 'patch': {'input_type':
            patch_input_type, 'output_type': type.VoidType(), 'errors':
            patch_error_dict, 'input_value_validator_list':
            patch_input_value_validator_list, 'output_validator_list':
            patch_output_validator_list, 'task_type': TaskType.NONE},
            'update': {'input_type': update_input_type, 'output_type': type
            .ReferenceType('com.vmware.nsx_policy.model_client',
            'IPSecVpnIkeProfile'), 'errors': update_error_dict,
            'input_value_validator_list': update_input_value_validator_list,
            'output_validator_list': update_output_validator_list,
            'task_type': TaskType.NONE}}
        rest_metadata = {'delete': delete_rest_metadata, 'get':
            get_rest_metadata, 'list': list_rest_metadata, 'patch':
            patch_rest_metadata, 'update': update_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.ipsec_vpn_ike_profiles', config=
            config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)


class _IpsecVpnTunnelProfilesStub(ApiInterfaceStub):

    def __init__(self, config):
        delete_input_type = type.StructType('operation-input', {
            'tunnel_profile_id': type.StringType()})
        delete_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template=
            '/policy/api/v1/infra/ipsec-vpn-tunnel-profiles/{tunnel-profile-id}'
            , path_variables={'tunnel_profile_id': 'tunnel-profile-id'},
            query_parameters={}, content_type='application/json')
        get_input_type = type.StructType('operation-input', {
            'tunnel_profile_id': type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template=
            '/policy/api/v1/infra/ipsec-vpn-tunnel-profiles/{tunnel-profile-id}'
            , path_variables={'tunnel_profile_id': 'tunnel-profile-id'},
            query_parameters={}, content_type='application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/ipsec-vpn-tunnel-profiles',
            path_variables={}, query_parameters={'cursor': 'cursor',
            'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        patch_input_type = type.StructType('operation-input', {
            'tunnel_profile_id': type.StringType(),
            'ip_sec_vpn_tunnel_profile': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'IPSecVpnTunnelProfile')})
        patch_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        patch_input_value_validator_list = [HasFieldsOfValidator()]
        patch_output_validator_list = []
        patch_rest_metadata = OperationRestMetadata(http_method='PATCH',
            url_template=
            '/policy/api/v1/infra/ipsec-vpn-tunnel-profiles/{tunnel-profile-id}'
            , request_body_parameter='ip_sec_vpn_tunnel_profile',
            path_variables={'tunnel_profile_id': 'tunnel-profile-id'},
            query_parameters={}, content_type='application/json')
        update_input_type = type.StructType('operation-input', {
            'tunnel_profile_id': type.StringType(),
            'ip_sec_vpn_tunnel_profile': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'IPSecVpnTunnelProfile')})
        update_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(http_method='PUT',
            url_template=
            '/policy/api/v1/infra/ipsec-vpn-tunnel-profiles/{tunnel-profile-id}'
            , request_body_parameter='ip_sec_vpn_tunnel_profile',
            path_variables={'tunnel_profile_id': 'tunnel-profile-id'},
            query_parameters={}, content_type='application/json')
        operations = {'delete': {'input_type': delete_input_type,
            'output_type': type.VoidType(), 'errors': delete_error_dict,
            'input_value_validator_list': delete_input_value_validator_list,
            'output_validator_list': delete_output_validator_list,
            'task_type': TaskType.NONE}, 'get': {'input_type':
            get_input_type, 'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'IPSecVpnTunnelProfile'),
            'errors': get_error_dict, 'input_value_validator_list':
            get_input_value_validator_list, 'output_validator_list':
            get_output_validator_list, 'task_type': TaskType.NONE}, 'list':
            {'input_type': list_input_type, 'output_type': type.
            ReferenceType('com.vmware.nsx_policy.model_client',
            'IPSecVpnTunnelProfileListResult'), 'errors': list_error_dict,
            'input_value_validator_list': list_input_value_validator_list,
            'output_validator_list': list_output_validator_list,
            'task_type': TaskType.NONE}, 'patch': {'input_type':
            patch_input_type, 'output_type': type.VoidType(), 'errors':
            patch_error_dict, 'input_value_validator_list':
            patch_input_value_validator_list, 'output_validator_list':
            patch_output_validator_list, 'task_type': TaskType.NONE},
            'update': {'input_type': update_input_type, 'output_type': type
            .ReferenceType('com.vmware.nsx_policy.model_client',
            'IPSecVpnTunnelProfile'), 'errors': update_error_dict,
            'input_value_validator_list': update_input_value_validator_list,
            'output_validator_list': update_output_validator_list,
            'task_type': TaskType.NONE}}
        rest_metadata = {'delete': delete_rest_metadata, 'get':
            get_rest_metadata, 'list': list_rest_metadata, 'patch':
            patch_rest_metadata, 'update': update_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.ipsec_vpn_tunnel_profiles', config
            =config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)


class _PartnerServicesStub(ApiInterfaceStub):

    def __init__(self, config):
        get_input_type = type.StructType('operation-input', {'service_name':
            type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = []
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template=
            '/policy/api/v1/infra/partner-services/{service-name}',
            path_variables={'service_name': 'service-name'},
            query_parameters={}, content_type='application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = []
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/partner-services',
            path_variables={}, query_parameters={'cursor': 'cursor',
            'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        operations = {'get': {'input_type': get_input_type, 'output_type':
            type.ReferenceType('com.vmware.nsx_policy.model_client',
            'ServiceDefinition'), 'errors': get_error_dict,
            'input_value_validator_list': get_input_value_validator_list,
            'output_validator_list': get_output_validator_list, 'task_type':
            TaskType.NONE}, 'list': {'input_type': list_input_type,
            'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client',
            'ServiceInsertionServiceListResult'), 'errors': list_error_dict,
            'input_value_validator_list': list_input_value_validator_list,
            'output_validator_list': list_output_validator_list,
            'task_type': TaskType.NONE}}
        rest_metadata = {'get': get_rest_metadata, 'list': list_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.partner_services', config=config,
            operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)


class _PortMirroringProfilesStub(ApiInterfaceStub):

    def __init__(self, config):
        delete_input_type = type.StructType('operation-input', {
            'port_mirroring_profile_id': type.StringType()})
        delete_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template=
            '/policy/api/v1/infra/port-mirroring-profiles/{port-mirroring-profile-id}'
            , path_variables={'port_mirroring_profile_id':
            'port-mirroring-profile-id'}, query_parameters={}, content_type
            ='application/json')
        get_input_type = type.StructType('operation-input', {
            'port_mirroring_profile_id': type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template=
            '/policy/api/v1/infra/port-mirroring-profiles/{port-mirroring-profile-id}'
            , path_variables={'port_mirroring_profile_id':
            'port-mirroring-profile-id'}, query_parameters={}, content_type
            ='application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()), 'included_fields': type.
            OptionalType(type.StringType()), 'page_size': type.OptionalType
            (type.IntegerType()), 'sort_ascending': type.OptionalType(type.
            BooleanType()), 'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/port-mirroring-profiles',
            path_variables={}, query_parameters={'cursor': 'cursor',
            'included_fields': 'included_fields', 'page_size': 'page_size',
            'sort_ascending': 'sort_ascending', 'sort_by': 'sort_by'},
            content_type='application/json')
        patch_input_type = type.StructType('operation-input', {
            'port_mirroring_profile_id': type.StringType(),
            'port_mirroring_profile': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'PortMirroringProfile')})
        patch_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        patch_input_value_validator_list = [HasFieldsOfValidator()]
        patch_output_validator_list = []
        patch_rest_metadata = OperationRestMetadata(http_method='PATCH',
            url_template=
            '/policy/api/v1/infra/port-mirroring-profiles/{port-mirroring-profile-id}'
            , request_body_parameter='port_mirroring_profile',
            path_variables={'port_mirroring_profile_id':
            'port-mirroring-profile-id'}, query_parameters={}, content_type
            ='application/json')
        update_input_type = type.StructType('operation-input', {
            'port_mirroring_profile_id': type.StringType(),
            'port_mirroring_profile': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'PortMirroringProfile')})
        update_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(http_method='PUT',
            url_template=
            '/policy/api/v1/infra/port-mirroring-profiles/{port-mirroring-profile-id}'
            , request_body_parameter='port_mirroring_profile',
            path_variables={'port_mirroring_profile_id':
            'port-mirroring-profile-id'}, query_parameters={}, content_type
            ='application/json')
        operations = {'delete': {'input_type': delete_input_type,
            'output_type': type.VoidType(), 'errors': delete_error_dict,
            'input_value_validator_list': delete_input_value_validator_list,
            'output_validator_list': delete_output_validator_list,
            'task_type': TaskType.NONE}, 'get': {'input_type':
            get_input_type, 'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'PortMirroringProfile'),
            'errors': get_error_dict, 'input_value_validator_list':
            get_input_value_validator_list, 'output_validator_list':
            get_output_validator_list, 'task_type': TaskType.NONE}, 'list':
            {'input_type': list_input_type, 'output_type': type.
            ReferenceType('com.vmware.nsx_policy.model_client',
            'PortMirroringProfileListResult'), 'errors': list_error_dict,
            'input_value_validator_list': list_input_value_validator_list,
            'output_validator_list': list_output_validator_list,
            'task_type': TaskType.NONE}, 'patch': {'input_type':
            patch_input_type, 'output_type': type.VoidType(), 'errors':
            patch_error_dict, 'input_value_validator_list':
            patch_input_value_validator_list, 'output_validator_list':
            patch_output_validator_list, 'task_type': TaskType.NONE},
            'update': {'input_type': update_input_type, 'output_type': type
            .ReferenceType('com.vmware.nsx_policy.model_client',
            'PortMirroringProfile'), 'errors': update_error_dict,
            'input_value_validator_list': update_input_value_validator_list,
            'output_validator_list': update_output_validator_list,
            'task_type': TaskType.NONE}}
        rest_metadata = {'delete': delete_rest_metadata, 'get':
            get_rest_metadata, 'list': list_rest_metadata, 'patch':
            patch_rest_metadata, 'update': update_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.port_mirroring_profiles', config=
            config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)


class _SegmentsStub(ApiInterfaceStub):

    def __init__(self, config):
        delete_input_type = type.StructType('operation-input', {
            'segment_id': type.StringType()})
        delete_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template='/policy/api/v1/infra/segments/{segment-id}',
            path_variables={'segment_id': 'segment-id'}, query_parameters={
            }, content_type='application/json')
        delete_0_input_type = type.StructType('operation-input', {
            'segment_id': type.StringType()})
        delete_0_error_dict = {'com.vmware.vapi.std.errors.service_unavailable'
            : type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_0_input_value_validator_list = []
        delete_0_output_validator_list = []
        delete_0_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template=
            '/policy/api/v1/infra/segments/{segment-id}?force=true',
            path_variables={'segment_id': 'segment-id'}, query_parameters={
            }, content_type='application/json')
        get_input_type = type.StructType('operation-input', {'segment_id':
            type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/segments/{segment-id}',
            path_variables={'segment_id': 'segment-id'}, query_parameters={
            }, content_type='application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/segments', path_variables={},
            query_parameters={'cursor': 'cursor',
            'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        patch_input_type = type.StructType('operation-input', {'segment_id':
            type.StringType(), 'segment': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'Segment')})
        patch_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        patch_input_value_validator_list = [HasFieldsOfValidator()]
        patch_output_validator_list = []
        patch_rest_metadata = OperationRestMetadata(http_method='PATCH',
            url_template='/policy/api/v1/infra/segments/{segment-id}',
            request_body_parameter='segment', path_variables={'segment_id':
            'segment-id'}, query_parameters={}, content_type='application/json'
            )
        update_input_type = type.StructType('operation-input', {
            'segment_id': type.StringType(), 'segment': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'Segment')})
        update_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(http_method='PUT',
            url_template='/policy/api/v1/infra/segments/{segment-id}',
            request_body_parameter='segment', path_variables={'segment_id':
            'segment-id'}, query_parameters={}, content_type='application/json'
            )
        operations = {'delete': {'input_type': delete_input_type,
            'output_type': type.VoidType(), 'errors': delete_error_dict,
            'input_value_validator_list': delete_input_value_validator_list,
            'output_validator_list': delete_output_validator_list,
            'task_type': TaskType.NONE}, 'delete_0': {'input_type':
            delete_0_input_type, 'output_type': type.VoidType(), 'errors':
            delete_0_error_dict, 'input_value_validator_list':
            delete_0_input_value_validator_list, 'output_validator_list':
            delete_0_output_validator_list, 'task_type': TaskType.NONE},
            'get': {'input_type': get_input_type, 'output_type': type.
            ReferenceType('com.vmware.nsx_policy.model_client', 'Segment'),
            'errors': get_error_dict, 'input_value_validator_list':
            get_input_value_validator_list, 'output_validator_list':
            get_output_validator_list, 'task_type': TaskType.NONE}, 'list':
            {'input_type': list_input_type, 'output_type': type.
            ReferenceType('com.vmware.nsx_policy.model_client',
            'SegmentListResult'), 'errors': list_error_dict,
            'input_value_validator_list': list_input_value_validator_list,
            'output_validator_list': list_output_validator_list,
            'task_type': TaskType.NONE}, 'patch': {'input_type':
            patch_input_type, 'output_type': type.VoidType(), 'errors':
            patch_error_dict, 'input_value_validator_list':
            patch_input_value_validator_list, 'output_validator_list':
            patch_output_validator_list, 'task_type': TaskType.NONE},
            'update': {'input_type': update_input_type, 'output_type': type
            .ReferenceType('com.vmware.nsx_policy.model_client', 'Segment'),
            'errors': update_error_dict, 'input_value_validator_list':
            update_input_value_validator_list, 'output_validator_list':
            update_output_validator_list, 'task_type': TaskType.NONE}}
        rest_metadata = {'delete': delete_rest_metadata, 'delete_0':
            delete_0_rest_metadata, 'get': get_rest_metadata, 'list':
            list_rest_metadata, 'patch': patch_rest_metadata, 'update':
            update_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.segments', config=config,
            operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)


class _ServicesStub(ApiInterfaceStub):

    def __init__(self, config):
        delete_input_type = type.StructType('operation-input', {
            'service_id': type.StringType()})
        delete_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(http_method='DELETE',
            url_template='/policy/api/v1/infra/services/{service-id}',
            path_variables={'service_id': 'service-id'}, query_parameters={
            }, content_type='application/json')
        get_input_type = type.StructType('operation-input', {'service_id':
            type.StringType()})
        get_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/services/{service-id}',
            path_variables={'service_id': 'service-id'}, query_parameters={
            }, content_type='application/json')
        list_input_type = type.StructType('operation-input', {'cursor':
            type.OptionalType(type.StringType()), 'default_service': type.
            OptionalType(type.BooleanType()),
            'include_mark_for_delete_objects': type.OptionalType(type.
            BooleanType()), 'included_fields': type.OptionalType(type.
            StringType()), 'page_size': type.OptionalType(type.IntegerType(
            )), 'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType())})
        list_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(http_method='GET',
            url_template='/policy/api/v1/infra/services', path_variables={},
            query_parameters={'cursor': 'cursor', 'default_service':
            'default_service', 'include_mark_for_delete_objects':
            'include_mark_for_delete_objects', 'included_fields':
            'included_fields', 'page_size': 'page_size', 'sort_ascending':
            'sort_ascending', 'sort_by': 'sort_by'}, content_type=
            'application/json')
        patch_input_type = type.StructType('operation-input', {'service_id':
            type.StringType(), 'service': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'Service')})
        patch_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        patch_input_value_validator_list = [HasFieldsOfValidator()]
        patch_output_validator_list = []
        patch_rest_metadata = OperationRestMetadata(http_method='PATCH',
            url_template='/policy/api/v1/infra/services/{service-id}',
            request_body_parameter='service', path_variables={'service_id':
            'service-id'}, query_parameters={}, content_type='application/json'
            )
        update_input_type = type.StructType('operation-input', {
            'service_id': type.StringType(), 'service': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'Service')})
        update_error_dict = {'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
            'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error': type.
            ReferenceType('com.vmware.vapi.std.errors_client',
            'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found': type.ReferenceType(
            'com.vmware.vapi.std.errors_client', 'NotFound')}
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(http_method='PUT',
            url_template='/policy/api/v1/infra/services/{service-id}',
            request_body_parameter='service', path_variables={'service_id':
            'service-id'}, query_parameters={}, content_type='application/json'
            )
        operations = {'delete': {'input_type': delete_input_type,
            'output_type': type.VoidType(), 'errors': delete_error_dict,
            'input_value_validator_list': delete_input_value_validator_list,
            'output_validator_list': delete_output_validator_list,
            'task_type': TaskType.NONE}, 'get': {'input_type':
            get_input_type, 'output_type': type.ReferenceType(
            'com.vmware.nsx_policy.model_client', 'Service'), 'errors':
            get_error_dict, 'input_value_validator_list':
            get_input_value_validator_list, 'output_validator_list':
            get_output_validator_list, 'task_type': TaskType.NONE}, 'list':
            {'input_type': list_input_type, 'output_type': type.
            ReferenceType('com.vmware.nsx_policy.model_client',
            'ServiceListResult'), 'errors': list_error_dict,
            'input_value_validator_list': list_input_value_validator_list,
            'output_validator_list': list_output_validator_list,
            'task_type': TaskType.NONE}, 'patch': {'input_type':
            patch_input_type, 'output_type': type.VoidType(), 'errors':
            patch_error_dict, 'input_value_validator_list':
            patch_input_value_validator_list, 'output_validator_list':
            patch_output_validator_list, 'task_type': TaskType.NONE},
            'update': {'input_type': update_input_type, 'output_type': type
            .ReferenceType('com.vmware.nsx_policy.model_client', 'Service'),
            'errors': update_error_dict, 'input_value_validator_list':
            update_input_value_validator_list, 'output_validator_list':
            update_output_validator_list, 'task_type': TaskType.NONE}}
        rest_metadata = {'delete': delete_rest_metadata, 'get':
            get_rest_metadata, 'list': list_rest_metadata, 'patch':
            patch_rest_metadata, 'update': update_rest_metadata}
        ApiInterfaceStub.__init__(self, iface_name=
            'com.vmware.nsx_policy.infra.services', config=config,
            operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)


class StubFactory(StubFactoryBase):
    _attrs = {'DhcpRelayConfigs': DhcpRelayConfigs, 'DhcpServerConfigs':
        DhcpServerConfigs, 'DnsForwarderZones': DnsForwarderZones,
        'Domains': Domains, 'Drafts': Drafts, 'GroupAssociations':
        GroupAssociations, 'IpfixCollectorProfiles': IpfixCollectorProfiles,
        'IpfixDfwCollectorProfiles': IpfixDfwCollectorProfiles,
        'IpfixDfwProfiles': IpfixDfwProfiles, 'IpfixL2CollectorProfiles':
        IpfixL2CollectorProfiles, 'IpfixL2Profiles': IpfixL2Profiles,
        'IpsecVpnDpdProfiles': IpsecVpnDpdProfiles, 'IpsecVpnIkeProfiles':
        IpsecVpnIkeProfiles, 'IpsecVpnTunnelProfiles':
        IpsecVpnTunnelProfiles, 'PartnerServices': PartnerServices,
        'PortMirroringProfiles': PortMirroringProfiles, 'Segments':
        Segments, 'Services': Services, 'domains':
        'com.vmware.nsx_policy.infra.domains_client.StubFactory', 'drafts':
        'com.vmware.nsx_policy.infra.drafts_client.StubFactory',
        'realized_state':
        'com.vmware.nsx_policy.infra.realized_state_client.StubFactory',
        'segments':
        'com.vmware.nsx_policy.infra.segments_client.StubFactory',
        'services':
        'com.vmware.nsx_policy.infra.services_client.StubFactory', 'sites':
        'com.vmware.nsx_policy.infra.sites_client.StubFactory', 'tier_0s':
        'com.vmware.nsx_policy.infra.tier_0s_client.StubFactory', 'tier_1s':
        'com.vmware.nsx_policy.infra.tier_1s_client.StubFactory'}

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

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

"""


"""

__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 DhcpRelayConfigs(VapiInterface):
    """
    
    """

    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.dhcp_relay_configs'
    """
    Identifier of the service in canonical form.
    """
    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _DhcpRelayConfigsStub)
        self._VAPI_OPERATION_IDS = {}


    def delete(self,
               dhcp_relay_config_id,
               ):
        """
        Delete DHCP relay configuration

        :type  dhcp_relay_config_id: :class:`str`
        :param dhcp_relay_config_id: DHCP relay config ID (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete',
                            {
                            'dhcp_relay_config_id': dhcp_relay_config_id,
                            })

    def get(self,
            dhcp_relay_config_id,
            ):
        """
        Read DHCP relay configuration

        :type  dhcp_relay_config_id: :class:`str`
        :param dhcp_relay_config_id: DHCP relay config ID (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.DhcpRelayConfig`
        :return: com.vmware.nsx_policy.model.DhcpRelayConfig
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get',
                            {
                            'dhcp_relay_config_id': dhcp_relay_config_id,
                            })

    def list(self,
             cursor=None,
             include_mark_for_delete_objects=None,
             included_fields=None,
             page_size=None,
             sort_ascending=None,
             sort_by=None,
             ):
        """
        Paginated list of all DHCP relay config instances

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.DhcpRelayConfigListResult`
        :return: com.vmware.nsx_policy.model.DhcpRelayConfigListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list',
                            {
                            'cursor': cursor,
                            'include_mark_for_delete_objects': include_mark_for_delete_objects,
                            'included_fields': included_fields,
                            'page_size': page_size,
                            'sort_ascending': sort_ascending,
                            'sort_by': sort_by,
                            })

    def patch(self,
              dhcp_relay_config_id,
              dhcp_relay_config,
              ):
        """
        If DHCP relay config with the dhcp-relay-config-id is not already
        present, create a new DHCP relay config instance. If it already exists,
        update the DHCP relay config instance with specified attributes.

        :type  dhcp_relay_config_id: :class:`str`
        :param dhcp_relay_config_id: DHCP relay config ID (required)
        :type  dhcp_relay_config: :class:`com.vmware.nsx_policy.model_client.DhcpRelayConfig`
        :param dhcp_relay_config: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch',
                            {
                            'dhcp_relay_config_id': dhcp_relay_config_id,
                            'dhcp_relay_config': dhcp_relay_config,
                            })

    def update(self,
               dhcp_relay_config_id,
               dhcp_relay_config,
               ):
        """
        If DHCP relay config with the dhcp-relay-config-id is not already
        present, create a new DHCP relay config instance. If it already exists,
        replace the DHCP relay config instance with this object.

        :type  dhcp_relay_config_id: :class:`str`
        :param dhcp_relay_config_id: DHCP relay config ID (required)
        :type  dhcp_relay_config: :class:`com.vmware.nsx_policy.model_client.DhcpRelayConfig`
        :param dhcp_relay_config: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.DhcpRelayConfig`
        :return: com.vmware.nsx_policy.model.DhcpRelayConfig
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update',
                            {
                            'dhcp_relay_config_id': dhcp_relay_config_id,
                            'dhcp_relay_config': dhcp_relay_config,
                            })
class DhcpServerConfigs(VapiInterface):
    """
    
    """

    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.dhcp_server_configs'
    """
    Identifier of the service in canonical form.
    """
    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _DhcpServerConfigsStub)
        self._VAPI_OPERATION_IDS = {}


    def delete(self,
               dhcp_server_config_id,
               ):
        """
        Delete DHCP server configuration

        :type  dhcp_server_config_id: :class:`str`
        :param dhcp_server_config_id: DHCP server config ID (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete',
                            {
                            'dhcp_server_config_id': dhcp_server_config_id,
                            })

    def get(self,
            dhcp_server_config_id,
            ):
        """
        Read DHCP server configuration

        :type  dhcp_server_config_id: :class:`str`
        :param dhcp_server_config_id: DHCP server config ID (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.DhcpServerConfig`
        :return: com.vmware.nsx_policy.model.DhcpServerConfig
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get',
                            {
                            'dhcp_server_config_id': dhcp_server_config_id,
                            })

    def list(self,
             cursor=None,
             include_mark_for_delete_objects=None,
             included_fields=None,
             page_size=None,
             sort_ascending=None,
             sort_by=None,
             ):
        """
        Paginated list of all DHCP server config instances

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.DhcpServerConfigListResult`
        :return: com.vmware.nsx_policy.model.DhcpServerConfigListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list',
                            {
                            'cursor': cursor,
                            'include_mark_for_delete_objects': include_mark_for_delete_objects,
                            'included_fields': included_fields,
                            'page_size': page_size,
                            'sort_ascending': sort_ascending,
                            'sort_by': sort_by,
                            })

    def patch(self,
              dhcp_server_config_id,
              dhcp_server_config,
              ):
        """
        If DHCP server config with the dhcp-server-config-id is not already
        present, create a new DHCP server config instance. If it already
        exists, update the DHCP server config instance with specified
        attributes. Realized entities of this API can be found using the path
        of Tier-0 that this config is applied on.

        :type  dhcp_server_config_id: :class:`str`
        :param dhcp_server_config_id: DHCP server config ID (required)
        :type  dhcp_server_config: :class:`com.vmware.nsx_policy.model_client.DhcpServerConfig`
        :param dhcp_server_config: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch',
                            {
                            'dhcp_server_config_id': dhcp_server_config_id,
                            'dhcp_server_config': dhcp_server_config,
                            })

    def update(self,
               dhcp_server_config_id,
               dhcp_server_config,
               ):
        """
        If DHCP server config with the dhcp-server-config-id is not already
        present, create a new DHCP server config instance. If it already
        exists, replace the DHCP server config instance with this object.
        Realized entities of this API can be found using the path of Tier-0
        that this config is applied on.

        :type  dhcp_server_config_id: :class:`str`
        :param dhcp_server_config_id: DHCP server config ID (required)
        :type  dhcp_server_config: :class:`com.vmware.nsx_policy.model_client.DhcpServerConfig`
        :param dhcp_server_config: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.DhcpServerConfig`
        :return: com.vmware.nsx_policy.model.DhcpServerConfig
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update',
                            {
                            'dhcp_server_config_id': dhcp_server_config_id,
                            'dhcp_server_config': dhcp_server_config,
                            })
class DnsForwarderZones(VapiInterface):
    """
    
    """

    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.dns_forwarder_zones'
    """
    Identifier of the service in canonical form.
    """
    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _DnsForwarderZonesStub)
        self._VAPI_OPERATION_IDS = {}


    def delete(self,
               dns_forwarder_zone_id,
               ):
        """
        Delete the DNS Forwarder Zone

        :type  dns_forwarder_zone_id: :class:`str`
        :param dns_forwarder_zone_id: DNS Forwarder Zone ID (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete',
                            {
                            'dns_forwarder_zone_id': dns_forwarder_zone_id,
                            })

    def get(self,
            dns_forwarder_zone_id,
            ):
        """
        Read the DNS Forwarder Zone

        :type  dns_forwarder_zone_id: :class:`str`
        :param dns_forwarder_zone_id: DNS Forwarder Zone ID (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.PolicyDnsForwarderZone`
        :return: com.vmware.nsx_policy.model.PolicyDnsForwarderZone
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get',
                            {
                            'dns_forwarder_zone_id': dns_forwarder_zone_id,
                            })

    def list(self,
             cursor=None,
             include_mark_for_delete_objects=None,
             included_fields=None,
             page_size=None,
             sort_ascending=None,
             sort_by=None,
             ):
        """
        Paginated list of all Dns Forwarder Zones

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.PolicyDnsForwarderZoneListResult`
        :return: com.vmware.nsx_policy.model.PolicyDnsForwarderZoneListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list',
                            {
                            'cursor': cursor,
                            'include_mark_for_delete_objects': include_mark_for_delete_objects,
                            'included_fields': included_fields,
                            'page_size': page_size,
                            'sort_ascending': sort_ascending,
                            'sort_by': sort_by,
                            })

    def patch(self,
              dns_forwarder_zone_id,
              policy_dns_forwarder_zone,
              ):
        """
        Create or update the DNS Forwarder Zone

        :type  dns_forwarder_zone_id: :class:`str`
        :param dns_forwarder_zone_id: DNS Forwarder Zone ID (required)
        :type  policy_dns_forwarder_zone: :class:`com.vmware.nsx_policy.model_client.PolicyDnsForwarderZone`
        :param policy_dns_forwarder_zone: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch',
                            {
                            'dns_forwarder_zone_id': dns_forwarder_zone_id,
                            'policy_dns_forwarder_zone': policy_dns_forwarder_zone,
                            })

    def update(self,
               dns_forwarder_zone_id,
               policy_dns_forwarder_zone,
               ):
        """
        Create or update the DNS Forwarder Zone

        :type  dns_forwarder_zone_id: :class:`str`
        :param dns_forwarder_zone_id: DNS Forwarder Zone ID (required)
        :type  policy_dns_forwarder_zone: :class:`com.vmware.nsx_policy.model_client.PolicyDnsForwarderZone`
        :param policy_dns_forwarder_zone: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.PolicyDnsForwarderZone`
        :return: com.vmware.nsx_policy.model.PolicyDnsForwarderZone
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update',
                            {
                            'dns_forwarder_zone_id': dns_forwarder_zone_id,
                            'policy_dns_forwarder_zone': policy_dns_forwarder_zone,
                            })
class Domains(VapiInterface):
    """
    
    """

    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.domains'
    """
    Identifier of the service in canonical form.
    """
    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _DomainsStub)
        self._VAPI_OPERATION_IDS = {}


    def get(self,
            domain_id,
            ):
        """
        Read a domain.

        :type  domain_id: :class:`str`
        :param domain_id: Domain ID (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.Domain`
        :return: com.vmware.nsx_policy.model.Domain
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get',
                            {
                            'domain_id': domain_id,
                            })

    def list(self,
             cursor=None,
             include_mark_for_delete_objects=None,
             included_fields=None,
             page_size=None,
             sort_ascending=None,
             sort_by=None,
             ):
        """
        Paginated list of all domains for infra.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.DomainListResult`
        :return: com.vmware.nsx_policy.model.DomainListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list',
                            {
                            'cursor': cursor,
                            'include_mark_for_delete_objects': include_mark_for_delete_objects,
                            'included_fields': included_fields,
                            'page_size': page_size,
                            'sort_ascending': sort_ascending,
                            'sort_by': sort_by,
                            })
class Drafts(VapiInterface):
    """
    
    """

    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.drafts'
    """
    Identifier of the service in canonical form.
    """
    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _DraftsStub)
        self._VAPI_OPERATION_IDS = {}


    def abort(self,
              draft_id,
              ):
        """
        If there is a failure during publish, the admin can choose to abort the
        publishing attempts. This will bring back the system to the current
        configuration, i.e just before the publish was invoked. If draft
        publishing is not in progress or already completed, then this is a
        NO-OP

        :type  draft_id: :class:`str`
        :param draft_id: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('abort',
                            {
                            'draft_id': draft_id,
                            })

    def delete(self,
               draft_id,
               ):
        """
        Delete a manual draft.

        :type  draft_id: :class:`str`
        :param draft_id: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete',
                            {
                            'draft_id': draft_id,
                            })

    def get(self,
            draft_id,
            ):
        """
        Read a draft for a given draft identifier.

        :type  draft_id: :class:`str`
        :param draft_id: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.PolicyDraft`
        :return: com.vmware.nsx_policy.model.PolicyDraft
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get',
                            {
                            'draft_id': draft_id,
                            })

    def list(self,
             auto_drafts=None,
             cursor=None,
             include_mark_for_delete_objects=None,
             included_fields=None,
             page_size=None,
             sort_ascending=None,
             sort_by=None,
             ):
        """
        List policy drafts.

        :type  auto_drafts: :class:`bool` or ``None``
        :param auto_drafts: Fetch list of draft based on is_auto_draft flag (optional)
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.PolicyDraftListResult`
        :return: com.vmware.nsx_policy.model.PolicyDraftListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list',
                            {
                            'auto_drafts': auto_drafts,
                            'cursor': cursor,
                            'include_mark_for_delete_objects': include_mark_for_delete_objects,
                            'included_fields': included_fields,
                            'page_size': page_size,
                            'sort_ascending': sort_ascending,
                            'sort_by': sort_by,
                            })

    def patch(self,
              draft_id,
              policy_draft,
              ):
        """
        Create a new manual draft if the specified draft id does not correspond
        to an existing draft. Update the manual draft otherwise. Auto draft can
        not be updated.

        :type  draft_id: :class:`str`
        :param draft_id: (required)
        :type  policy_draft: :class:`com.vmware.nsx_policy.model_client.PolicyDraft`
        :param policy_draft: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch',
                            {
                            'draft_id': draft_id,
                            'policy_draft': policy_draft,
                            })

    def publish(self,
                draft_id,
                infra,
                ):
        """
        Read a draft and publish it by applying changes onto current
        configuration.

        :type  draft_id: :class:`str`
        :param draft_id: (required)
        :type  infra: :class:`com.vmware.nsx_policy.model_client.Infra`
        :param infra: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('publish',
                            {
                            'draft_id': draft_id,
                            'infra': infra,
                            })

    def update(self,
               draft_id,
               policy_draft,
               ):
        """
        Create a new manual draft if the specified draft id does not correspond
        to an existing draft. Update the manual draft otherwise. Auto draft can
        not be updated.

        :type  draft_id: :class:`str`
        :param draft_id: (required)
        :type  policy_draft: :class:`com.vmware.nsx_policy.model_client.PolicyDraft`
        :param policy_draft: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.PolicyDraft`
        :return: com.vmware.nsx_policy.model.PolicyDraft
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update',
                            {
                            'draft_id': draft_id,
                            'policy_draft': policy_draft,
                            })
class GroupAssociations(VapiInterface):
    """
    
    """

    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.group_associations'
    """
    Identifier of the service in canonical form.
    """
    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _GroupAssociationsStub)
        self._VAPI_OPERATION_IDS = {}


    def list(self,
             intent_path,
             cursor=None,
             enforcement_point_path=None,
             include_mark_for_delete_objects=None,
             included_fields=None,
             page_size=None,
             sort_ascending=None,
             sort_by=None,
             ):
        """
        Get policy groups for which the given object is a member.

        :type  intent_path: :class:`str`
        :param intent_path: String path of the intent object (required)
        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  enforcement_point_path: :class:`str` or ``None``
        :param enforcement_point_path: String Path of the enforcement point (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.PolicyResourceReferenceForEPListResult`
        :return: com.vmware.nsx_policy.model.PolicyResourceReferenceForEPListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list',
                            {
                            'intent_path': intent_path,
                            'cursor': cursor,
                            'enforcement_point_path': enforcement_point_path,
                            'include_mark_for_delete_objects': include_mark_for_delete_objects,
                            'included_fields': included_fields,
                            'page_size': page_size,
                            'sort_ascending': sort_ascending,
                            'sort_by': sort_by,
                            })
class IpfixCollectorProfiles(VapiInterface):
    """
    
    """

    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.ipfix_collector_profiles'
    """
    Identifier of the service in canonical form.
    """
    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _IpfixCollectorProfilesStub)
        self._VAPI_OPERATION_IDS = {}


    def delete(self,
               ipfix_collector_profile_id,
               ):
        """
        API deletes IPFIX collector profile. Flow forwarding to collector will
        be stopped. This API is deprecated. Please use the following API:
        https://<policy-mgr>/policy/api/v1/infra/ipfix-l2-collector-profiles

        :type  ipfix_collector_profile_id: :class:`str`
        :param ipfix_collector_profile_id: IPFIX collector Profile id (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete',
                            {
                            'ipfix_collector_profile_id': ipfix_collector_profile_id,
                            })

    def get(self,
            ipfix_collector_profile_id,
            ):
        """
        API will return details of IPFIX collector profile. If profile does not
        exist, it will return 404. This API is deprecated. Please use the
        following API:
        https://<policy-mgr>/policy/api/v1/infra/ipfix-l2-collector-profiles

        :type  ipfix_collector_profile_id: :class:`str`
        :param ipfix_collector_profile_id: IPFIX collector profile id (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXCollectorProfile`
        :return: com.vmware.nsx_policy.model.IPFIXCollectorProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get',
                            {
                            'ipfix_collector_profile_id': ipfix_collector_profile_id,
                            })

    def list(self,
             cursor=None,
             include_mark_for_delete_objects=None,
             included_fields=None,
             page_size=None,
             sort_ascending=None,
             sort_by=None,
             ):
        """
        API will provide list of all IPFIX collector profiles and their
        details. This API is deprecated. Please use the following API:
        https://<policy-mgr>/policy/api/v1/infra/ipfix-l2-collector-profiles

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXCollectorProfileListResult`
        :return: com.vmware.nsx_policy.model.IPFIXCollectorProfileListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list',
                            {
                            'cursor': cursor,
                            'include_mark_for_delete_objects': include_mark_for_delete_objects,
                            'included_fields': included_fields,
                            'page_size': page_size,
                            'sort_ascending': sort_ascending,
                            'sort_by': sort_by,
                            })

    def patch(self,
              ipfix_collector_profile_id,
              i_pfix_collector_profile,
              ):
        """
        Create a new IPFIX collector profile if the IPFIX collector profile
        with given id does not already exist. If the IPFIX collector profile
        with the given id already exists, patch with the existing IPFIX
        collector profile. This API is deprecated. Please use the following
        API:
        https://<policy-mgr>/policy/api/v1/infra/ipfix-l2-collector-profiles

        :type  ipfix_collector_profile_id: :class:`str`
        :param ipfix_collector_profile_id: IPFIX collector profile id (required)
        :type  i_pfix_collector_profile: :class:`com.vmware.nsx_policy.model_client.IPFIXCollectorProfile`
        :param i_pfix_collector_profile: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch',
                            {
                            'ipfix_collector_profile_id': ipfix_collector_profile_id,
                            'i_pfix_collector_profile': i_pfix_collector_profile,
                            })

    def update(self,
               ipfix_collector_profile_id,
               i_pfix_collector_profile,
               ):
        """
        Create or Replace IPFIX collector profile. IPFIX data will be sent to
        IPFIX collector port. This API is deprecated. Please use the following
        API:
        https://<policy-mgr>/policy/api/v1/infra/ipfix-l2-collector-profiles

        :type  ipfix_collector_profile_id: :class:`str`
        :param ipfix_collector_profile_id: IPFIX collector profile id (required)
        :type  i_pfix_collector_profile: :class:`com.vmware.nsx_policy.model_client.IPFIXCollectorProfile`
        :param i_pfix_collector_profile: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXCollectorProfile`
        :return: com.vmware.nsx_policy.model.IPFIXCollectorProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update',
                            {
                            'ipfix_collector_profile_id': ipfix_collector_profile_id,
                            'i_pfix_collector_profile': i_pfix_collector_profile,
                            })
class IpfixDfwCollectorProfiles(VapiInterface):
    """
    
    """

    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.ipfix_dfw_collector_profiles'
    """
    Identifier of the service in canonical form.
    """
    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _IpfixDfwCollectorProfilesStub)
        self._VAPI_OPERATION_IDS = {}


    def delete(self,
               ipfix_dfw_collector_profile_id,
               ):
        """
        API deletes IPFIX dfw collector profile. Flow forwarding to collector
        will be stopped.

        :type  ipfix_dfw_collector_profile_id: :class:`str`
        :param ipfix_dfw_collector_profile_id: IPFIX dfw collector Profile id (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete',
                            {
                            'ipfix_dfw_collector_profile_id': ipfix_dfw_collector_profile_id,
                            })

    def get(self,
            ipfix_dfw_collector_profile_id,
            ):
        """
        API will return details of IPFIX dfw collector profile. If profile does
        not exist, it will return 404.

        :type  ipfix_dfw_collector_profile_id: :class:`str`
        :param ipfix_dfw_collector_profile_id: IPFIX dfw collector profile id (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXDFWCollectorProfile`
        :return: com.vmware.nsx_policy.model.IPFIXDFWCollectorProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get',
                            {
                            'ipfix_dfw_collector_profile_id': ipfix_dfw_collector_profile_id,
                            })

    def list(self,
             cursor=None,
             include_mark_for_delete_objects=None,
             included_fields=None,
             page_size=None,
             sort_ascending=None,
             sort_by=None,
             ):
        """
        API will provide list of all IPFIX dfw collector profiles and their
        details.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXDFWCollectorProfileListResult`
        :return: com.vmware.nsx_policy.model.IPFIXDFWCollectorProfileListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list',
                            {
                            'cursor': cursor,
                            'include_mark_for_delete_objects': include_mark_for_delete_objects,
                            'included_fields': included_fields,
                            'page_size': page_size,
                            'sort_ascending': sort_ascending,
                            'sort_by': sort_by,
                            })

    def patch(self,
              ipfix_dfw_collector_profile_id,
              i_pfixdfw_collector_profile,
              ):
        """
        Create a new IPFIX dfw collector profile if the IPFIX dfw collector
        profile with given id does not already exist. If the IPFIX dfw
        collector profile with the given id already exists, patch with the
        existing IPFIX dfw collector profile.

        :type  ipfix_dfw_collector_profile_id: :class:`str`
        :param ipfix_dfw_collector_profile_id: (required)
        :type  i_pfixdfw_collector_profile: :class:`com.vmware.nsx_policy.model_client.IPFIXDFWCollectorProfile`
        :param i_pfixdfw_collector_profile: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch',
                            {
                            'ipfix_dfw_collector_profile_id': ipfix_dfw_collector_profile_id,
                            'i_pfixdfw_collector_profile': i_pfixdfw_collector_profile,
                            })

    def update(self,
               ipfix_dfw_collector_profile_id,
               i_pfixdfw_collector_profile,
               ):
        """
        Create or Replace IPFIX dfw collector profile. IPFIX data will be sent
        to IPFIX collector port.

        :type  ipfix_dfw_collector_profile_id: :class:`str`
        :param ipfix_dfw_collector_profile_id: IPFIX dfw collector profile id (required)
        :type  i_pfixdfw_collector_profile: :class:`com.vmware.nsx_policy.model_client.IPFIXDFWCollectorProfile`
        :param i_pfixdfw_collector_profile: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXDFWCollectorProfile`
        :return: com.vmware.nsx_policy.model.IPFIXDFWCollectorProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update',
                            {
                            'ipfix_dfw_collector_profile_id': ipfix_dfw_collector_profile_id,
                            'i_pfixdfw_collector_profile': i_pfixdfw_collector_profile,
                            })
class IpfixDfwProfiles(VapiInterface):
    """
    
    """

    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.ipfix_dfw_profiles'
    """
    Identifier of the service in canonical form.
    """
    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _IpfixDfwProfilesStub)
        self._VAPI_OPERATION_IDS = {}


    def delete(self,
               ipfix_dfw_profile_id,
               ):
        """
        API deletes IPFIX DFW Profile. Selected IPFIX Collectors will stop
        receiving flows.

        :type  ipfix_dfw_profile_id: :class:`str`
        :param ipfix_dfw_profile_id: IPFIX DFW Profile ID (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete',
                            {
                            'ipfix_dfw_profile_id': ipfix_dfw_profile_id,
                            })

    def get(self,
            ipfix_dfw_profile_id,
            ):
        """
        API will return details of IPFIX DFW profile.

        :type  ipfix_dfw_profile_id: :class:`str`
        :param ipfix_dfw_profile_id: IPFIX DFW collection id (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXDFWProfile`
        :return: com.vmware.nsx_policy.model.IPFIXDFWProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get',
                            {
                            'ipfix_dfw_profile_id': ipfix_dfw_profile_id,
                            })

    def list(self,
             cursor=None,
             include_mark_for_delete_objects=None,
             included_fields=None,
             page_size=None,
             sort_ascending=None,
             sort_by=None,
             ):
        """
        API provides list IPFIX DFW profiles available on selected logical DFW.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXDFWProfileListResult`
        :return: com.vmware.nsx_policy.model.IPFIXDFWProfileListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list',
                            {
                            'cursor': cursor,
                            'include_mark_for_delete_objects': include_mark_for_delete_objects,
                            'included_fields': included_fields,
                            'page_size': page_size,
                            'sort_ascending': sort_ascending,
                            'sort_by': sort_by,
                            })

    def patch(self,
              ipfix_dfw_profile_id,
              i_pfixdfw_profile,
              ):
        """
        Create a new IPFIX DFW profile if the IPFIX DFW profile with given id
        does not already exist. If the IPFIX DFW profile with the given id
        already exists, patch with the existing IPFIX DFW profile.

        :type  ipfix_dfw_profile_id: :class:`str`
        :param ipfix_dfw_profile_id: IPFIX DFW Profile ID (required)
        :type  i_pfixdfw_profile: :class:`com.vmware.nsx_policy.model_client.IPFIXDFWProfile`
        :param i_pfixdfw_profile: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch',
                            {
                            'ipfix_dfw_profile_id': ipfix_dfw_profile_id,
                            'i_pfixdfw_profile': i_pfixdfw_profile,
                            })

    def update(self,
               ipfix_dfw_profile_id,
               i_pfixdfw_profile,
               ):
        """
        Create or replace IPFIX DFW profile. Config will start forwarding data
        to provided IPFIX DFW collector.

        :type  ipfix_dfw_profile_id: :class:`str`
        :param ipfix_dfw_profile_id: IPFIX DFW Profile ID (required)
        :type  i_pfixdfw_profile: :class:`com.vmware.nsx_policy.model_client.IPFIXDFWProfile`
        :param i_pfixdfw_profile: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXDFWProfile`
        :return: com.vmware.nsx_policy.model.IPFIXDFWProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update',
                            {
                            'ipfix_dfw_profile_id': ipfix_dfw_profile_id,
                            'i_pfixdfw_profile': i_pfixdfw_profile,
                            })
class IpfixL2CollectorProfiles(VapiInterface):
    """
    
    """

    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.ipfix_l2_collector_profiles'
    """
    Identifier of the service in canonical form.
    """
    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _IpfixL2CollectorProfilesStub)
        self._VAPI_OPERATION_IDS = {}


    def delete(self,
               ipfix_l2_collector_profile_id,
               ):
        """
        API deletes IPFIX collector profile. Flow forwarding to collector will
        be stopped.

        :type  ipfix_l2_collector_profile_id: :class:`str`
        :param ipfix_l2_collector_profile_id: IPFIX collector Profile id (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete',
                            {
                            'ipfix_l2_collector_profile_id': ipfix_l2_collector_profile_id,
                            })

    def get(self,
            ipfix_l2_collector_profile_id,
            ):
        """
        API will return details of IPFIX collector profile.

        :type  ipfix_l2_collector_profile_id: :class:`str`
        :param ipfix_l2_collector_profile_id: IPFIX collector profile id (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXL2CollectorProfile`
        :return: com.vmware.nsx_policy.model.IPFIXL2CollectorProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get',
                            {
                            'ipfix_l2_collector_profile_id': ipfix_l2_collector_profile_id,
                            })

    def list(self,
             cursor=None,
             include_mark_for_delete_objects=None,
             included_fields=None,
             page_size=None,
             sort_ascending=None,
             sort_by=None,
             ):
        """
        API will provide list of all IPFIX collector profiles and their
        details.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXL2CollectorProfileListResult`
        :return: com.vmware.nsx_policy.model.IPFIXL2CollectorProfileListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list',
                            {
                            'cursor': cursor,
                            'include_mark_for_delete_objects': include_mark_for_delete_objects,
                            'included_fields': included_fields,
                            'page_size': page_size,
                            'sort_ascending': sort_ascending,
                            'sort_by': sort_by,
                            })

    def patch(self,
              ipfix_l2_collector_profile_id,
              i_pfix_l2_collector_profile,
              ):
        """
        Create a new IPFIX collector profile if the IPFIX collector profile
        with given id does not already exist. If the IPFIX collector profile
        with the given id already exists, patch with the existing IPFIX
        collector profile.

        :type  ipfix_l2_collector_profile_id: :class:`str`
        :param ipfix_l2_collector_profile_id: IPFIX collector profile id (required)
        :type  i_pfix_l2_collector_profile: :class:`com.vmware.nsx_policy.model_client.IPFIXL2CollectorProfile`
        :param i_pfix_l2_collector_profile: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch',
                            {
                            'ipfix_l2_collector_profile_id': ipfix_l2_collector_profile_id,
                            'i_pfix_l2_collector_profile': i_pfix_l2_collector_profile,
                            })

    def update(self,
               ipfix_l2_collector_profile_id,
               i_pfix_l2_collector_profile,
               ):
        """
        Create or Replace IPFIX collector profile. IPFIX data will be sent to
        IPFIX collector.

        :type  ipfix_l2_collector_profile_id: :class:`str`
        :param ipfix_l2_collector_profile_id: IPFIX collector profile id (required)
        :type  i_pfix_l2_collector_profile: :class:`com.vmware.nsx_policy.model_client.IPFIXL2CollectorProfile`
        :param i_pfix_l2_collector_profile: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXL2CollectorProfile`
        :return: com.vmware.nsx_policy.model.IPFIXL2CollectorProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update',
                            {
                            'ipfix_l2_collector_profile_id': ipfix_l2_collector_profile_id,
                            'i_pfix_l2_collector_profile': i_pfix_l2_collector_profile,
                            })
class IpfixL2Profiles(VapiInterface):
    """
    
    """

    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.ipfix_l2_profiles'
    """
    Identifier of the service in canonical form.
    """
    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _IpfixL2ProfilesStub)
        self._VAPI_OPERATION_IDS = {}


    def delete(self,
               ipfix_l2_profile_id,
               ):
        """
        API deletes IPFIX L2 Profile. Flow forwarding to selected collector
        will be stopped.

        :type  ipfix_l2_profile_id: :class:`str`
        :param ipfix_l2_profile_id: IPFIX L2 Profile ID (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete',
                            {
                            'ipfix_l2_profile_id': ipfix_l2_profile_id,
                            })

    def get(self,
            ipfix_l2_profile_id,
            ):
        """
        API will return details of IPFIX L2 profile.

        :type  ipfix_l2_profile_id: :class:`str`
        :param ipfix_l2_profile_id: IPFIX L2 profile id (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXL2Profile`
        :return: com.vmware.nsx_policy.model.IPFIXL2Profile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get',
                            {
                            'ipfix_l2_profile_id': ipfix_l2_profile_id,
                            })

    def list(self,
             cursor=None,
             include_mark_for_delete_objects=None,
             included_fields=None,
             page_size=None,
             sort_ascending=None,
             sort_by=None,
             ):
        """
        API provides list IPFIX L2 Profiles available on selected logical l2.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXL2ProfileListResult`
        :return: com.vmware.nsx_policy.model.IPFIXL2ProfileListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list',
                            {
                            'cursor': cursor,
                            'include_mark_for_delete_objects': include_mark_for_delete_objects,
                            'included_fields': included_fields,
                            'page_size': page_size,
                            'sort_ascending': sort_ascending,
                            'sort_by': sort_by,
                            })

    def patch(self,
              ipfix_l2_profile_id,
              i_pfix_l2_profile,
              ):
        """
        Create a new IPFIX L2 profile if the IPFIX L2 profile with given id
        does not already exist. If the IPFIX L2 profile with the given id
        already exists, patch with the existing IPFIX L2 profile.

        :type  ipfix_l2_profile_id: :class:`str`
        :param ipfix_l2_profile_id: IPFIX L2 Profile ID (required)
        :type  i_pfix_l2_profile: :class:`com.vmware.nsx_policy.model_client.IPFIXL2Profile`
        :param i_pfix_l2_profile: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch',
                            {
                            'ipfix_l2_profile_id': ipfix_l2_profile_id,
                            'i_pfix_l2_profile': i_pfix_l2_profile,
                            })

    def update(self,
               ipfix_l2_profile_id,
               i_pfix_l2_profile,
               ):
        """
        Create or replace IPFIX L2 Profile. Profile is reusable entity. Single
        profile can attached multiple bindings e.g group, segment and port.

        :type  ipfix_l2_profile_id: :class:`str`
        :param ipfix_l2_profile_id: IPFIX L2 Profile ID (required)
        :type  i_pfix_l2_profile: :class:`com.vmware.nsx_policy.model_client.IPFIXL2Profile`
        :param i_pfix_l2_profile: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPFIXL2Profile`
        :return: com.vmware.nsx_policy.model.IPFIXL2Profile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update',
                            {
                            'ipfix_l2_profile_id': ipfix_l2_profile_id,
                            'i_pfix_l2_profile': i_pfix_l2_profile,
                            })
class IpsecVpnDpdProfiles(VapiInterface):
    """
    
    """

    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.ipsec_vpn_dpd_profiles'
    """
    Identifier of the service in canonical form.
    """
    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _IpsecVpnDpdProfilesStub)
        self._VAPI_OPERATION_IDS = {}


    def delete(self,
               dpd_profile_id,
               ):
        """
        Delete custom dead peer detection (DPD) profile. Profile can not be
        deleted if profile has references to it.

        :type  dpd_profile_id: :class:`str`
        :param dpd_profile_id: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete',
                            {
                            'dpd_profile_id': dpd_profile_id,
                            })

    def get(self,
            dpd_profile_id,
            ):
        """
        Get custom dead peer detection (DPD) profile, given the particular id.

        :type  dpd_profile_id: :class:`str`
        :param dpd_profile_id: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPSecVpnDpdProfile`
        :return: com.vmware.nsx_policy.model.IPSecVpnDpdProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get',
                            {
                            'dpd_profile_id': dpd_profile_id,
                            })

    def list(self,
             cursor=None,
             include_mark_for_delete_objects=None,
             included_fields=None,
             page_size=None,
             sort_ascending=None,
             sort_by=None,
             ):
        """
        Get paginated list of all DPD Profiles.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPSecVpnDpdProfileListResult`
        :return: com.vmware.nsx_policy.model.IPSecVpnDpdProfileListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list',
                            {
                            'cursor': cursor,
                            'include_mark_for_delete_objects': include_mark_for_delete_objects,
                            'included_fields': included_fields,
                            'page_size': page_size,
                            'sort_ascending': sort_ascending,
                            'sort_by': sort_by,
                            })

    def patch(self,
              dpd_profile_id,
              ip_sec_vpn_dpd_profile,
              ):
        """
        Create or patch dead peer detection (DPD) profile. Any change in
        profile affects all sessions consuming this profile. System will be
        provisioned with system owned editable default DPD profile. Any change
        in profile affects all sessions consuming this profile.

        :type  dpd_profile_id: :class:`str`
        :param dpd_profile_id: (required)
        :type  ip_sec_vpn_dpd_profile: :class:`com.vmware.nsx_policy.model_client.IPSecVpnDpdProfile`
        :param ip_sec_vpn_dpd_profile: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch',
                            {
                            'dpd_profile_id': dpd_profile_id,
                            'ip_sec_vpn_dpd_profile': ip_sec_vpn_dpd_profile,
                            })

    def update(self,
               dpd_profile_id,
               ip_sec_vpn_dpd_profile,
               ):
        """
        Create or patch dead peer detection (DPD) profile. Any change in
        profile affects all sessions consuming this profile. System will be
        provisioned with system owned editable default DPD profile. Any change
        in profile affects all sessions consuming this profile. Revision is
        optional for creation and required for update.

        :type  dpd_profile_id: :class:`str`
        :param dpd_profile_id: (required)
        :type  ip_sec_vpn_dpd_profile: :class:`com.vmware.nsx_policy.model_client.IPSecVpnDpdProfile`
        :param ip_sec_vpn_dpd_profile: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPSecVpnDpdProfile`
        :return: com.vmware.nsx_policy.model.IPSecVpnDpdProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update',
                            {
                            'dpd_profile_id': dpd_profile_id,
                            'ip_sec_vpn_dpd_profile': ip_sec_vpn_dpd_profile,
                            })
class IpsecVpnIkeProfiles(VapiInterface):
    """
    
    """

    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.ipsec_vpn_ike_profiles'
    """
    Identifier of the service in canonical form.
    """
    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _IpsecVpnIkeProfilesStub)
        self._VAPI_OPERATION_IDS = {}


    def delete(self,
               ike_profile_id,
               ):
        """
        Delete custom IKE Profile. Profile can not be deleted if profile has
        references to it.

        :type  ike_profile_id: :class:`str`
        :param ike_profile_id: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete',
                            {
                            'ike_profile_id': ike_profile_id,
                            })

    def get(self,
            ike_profile_id,
            ):
        """
        Get custom IKE Profile, given the particular id.

        :type  ike_profile_id: :class:`str`
        :param ike_profile_id: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPSecVpnIkeProfile`
        :return: com.vmware.nsx_policy.model.IPSecVpnIkeProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get',
                            {
                            'ike_profile_id': ike_profile_id,
                            })

    def list(self,
             cursor=None,
             include_mark_for_delete_objects=None,
             included_fields=None,
             page_size=None,
             sort_ascending=None,
             sort_by=None,
             ):
        """
        Get paginated list of all IKE Profiles.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPSecVpnIkeProfileListResult`
        :return: com.vmware.nsx_policy.model.IPSecVpnIkeProfileListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list',
                            {
                            'cursor': cursor,
                            'include_mark_for_delete_objects': include_mark_for_delete_objects,
                            'included_fields': included_fields,
                            'page_size': page_size,
                            'sort_ascending': sort_ascending,
                            'sort_by': sort_by,
                            })

    def patch(self,
              ike_profile_id,
              ip_sec_vpn_ike_profile,
              ):
        """
        Create or patch custom internet key exchange (IKE) Profile. IKE Profile
        is a reusable profile that captures IKE and phase one negotiation
        parameters. System will be pre provisioned with system owned editable
        default IKE profile and suggested set of profiles that can be used for
        peering with popular remote peers like AWS VPN. User can create custom
        profiles as needed. Any change in profile affects all sessions
        consuming this profile.

        :type  ike_profile_id: :class:`str`
        :param ike_profile_id: (required)
        :type  ip_sec_vpn_ike_profile: :class:`com.vmware.nsx_policy.model_client.IPSecVpnIkeProfile`
        :param ip_sec_vpn_ike_profile: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch',
                            {
                            'ike_profile_id': ike_profile_id,
                            'ip_sec_vpn_ike_profile': ip_sec_vpn_ike_profile,
                            })

    def update(self,
               ike_profile_id,
               ip_sec_vpn_ike_profile,
               ):
        """
        Create or fully replace custom internet key exchange (IKE) Profile. IKE
        Profile is a reusable profile that captures IKE and phase one
        negotiation parameters. System will be pre provisioned with system
        owned editable default IKE profile and suggested set of profiles that
        can be used for peering with popular remote peers like AWS VPN. User
        can create custom profiles as needed. Any change in profile affects all
        sessions consuming this profile. Revision is optional for creation and
        required for update.

        :type  ike_profile_id: :class:`str`
        :param ike_profile_id: (required)
        :type  ip_sec_vpn_ike_profile: :class:`com.vmware.nsx_policy.model_client.IPSecVpnIkeProfile`
        :param ip_sec_vpn_ike_profile: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPSecVpnIkeProfile`
        :return: com.vmware.nsx_policy.model.IPSecVpnIkeProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update',
                            {
                            'ike_profile_id': ike_profile_id,
                            'ip_sec_vpn_ike_profile': ip_sec_vpn_ike_profile,
                            })
class IpsecVpnTunnelProfiles(VapiInterface):
    """
    
    """

    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.ipsec_vpn_tunnel_profiles'
    """
    Identifier of the service in canonical form.
    """
    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _IpsecVpnTunnelProfilesStub)
        self._VAPI_OPERATION_IDS = {}


    def delete(self,
               tunnel_profile_id,
               ):
        """
        Delete custom IPSec tunnel Profile. Profile can not be deleted if
        profile has references to it.

        :type  tunnel_profile_id: :class:`str`
        :param tunnel_profile_id: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete',
                            {
                            'tunnel_profile_id': tunnel_profile_id,
                            })

    def get(self,
            tunnel_profile_id,
            ):
        """
        Get custom IPSec tunnel Profile, given the particular id.

        :type  tunnel_profile_id: :class:`str`
        :param tunnel_profile_id: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPSecVpnTunnelProfile`
        :return: com.vmware.nsx_policy.model.IPSecVpnTunnelProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get',
                            {
                            'tunnel_profile_id': tunnel_profile_id,
                            })

    def list(self,
             cursor=None,
             include_mark_for_delete_objects=None,
             included_fields=None,
             page_size=None,
             sort_ascending=None,
             sort_by=None,
             ):
        """
        Get paginated list of all IPSec tunnel Profiles.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPSecVpnTunnelProfileListResult`
        :return: com.vmware.nsx_policy.model.IPSecVpnTunnelProfileListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list',
                            {
                            'cursor': cursor,
                            'include_mark_for_delete_objects': include_mark_for_delete_objects,
                            'included_fields': included_fields,
                            'page_size': page_size,
                            'sort_ascending': sort_ascending,
                            'sort_by': sort_by,
                            })

    def patch(self,
              tunnel_profile_id,
              ip_sec_vpn_tunnel_profile,
              ):
        """
        Create or patch custom IPSec tunnel profile. IPSec tunnel profile is a
        reusable profile that captures phase two negotiation parameters and
        tunnel properties. System will be provisioned with system owned
        editable default IPSec tunnel profile. Any change in profile affects
        all sessions consuming this profile.

        :type  tunnel_profile_id: :class:`str`
        :param tunnel_profile_id: (required)
        :type  ip_sec_vpn_tunnel_profile: :class:`com.vmware.nsx_policy.model_client.IPSecVpnTunnelProfile`
        :param ip_sec_vpn_tunnel_profile: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch',
                            {
                            'tunnel_profile_id': tunnel_profile_id,
                            'ip_sec_vpn_tunnel_profile': ip_sec_vpn_tunnel_profile,
                            })

    def update(self,
               tunnel_profile_id,
               ip_sec_vpn_tunnel_profile,
               ):
        """
        Create or fully replace custom IPSec tunnel profile. IPSec tunnel
        profile is a reusable profile that captures phase two negotiation
        parameters and tunnel properties. System will be provisioned with
        system owned editable default IPSec tunnel profile. Any change in
        profile affects all sessions consuming this profile. Revision is
        optional for creation and required for update.

        :type  tunnel_profile_id: :class:`str`
        :param tunnel_profile_id: (required)
        :type  ip_sec_vpn_tunnel_profile: :class:`com.vmware.nsx_policy.model_client.IPSecVpnTunnelProfile`
        :param ip_sec_vpn_tunnel_profile: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.IPSecVpnTunnelProfile`
        :return: com.vmware.nsx_policy.model.IPSecVpnTunnelProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update',
                            {
                            'tunnel_profile_id': tunnel_profile_id,
                            'ip_sec_vpn_tunnel_profile': ip_sec_vpn_tunnel_profile,
                            })
class PartnerServices(VapiInterface):
    """
    
    """

    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.partner_services'
    """
    Identifier of the service in canonical form.
    """
    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _PartnerServicesStub)
        self._VAPI_OPERATION_IDS = {}


    def get(self,
            service_name,
            ):
        """
        Read the specific partner service identified by provided name.

        :type  service_name: :class:`str`
        :param service_name: Name of the service (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.ServiceDefinition`
        :return: com.vmware.nsx_policy.model.ServiceDefinition
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get',
                            {
                            'service_name': service_name,
                            })

    def list(self,
             cursor=None,
             include_mark_for_delete_objects=None,
             included_fields=None,
             page_size=None,
             sort_ascending=None,
             sort_by=None,
             ):
        """
        Read all the partner services available for service insertion

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.ServiceInsertionServiceListResult`
        :return: com.vmware.nsx_policy.model.ServiceInsertionServiceListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list',
                            {
                            'cursor': cursor,
                            'include_mark_for_delete_objects': include_mark_for_delete_objects,
                            'included_fields': included_fields,
                            'page_size': page_size,
                            'sort_ascending': sort_ascending,
                            'sort_by': sort_by,
                            })
class PortMirroringProfiles(VapiInterface):
    """
    
    """

    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.port_mirroring_profiles'
    """
    Identifier of the service in canonical form.
    """
    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _PortMirroringProfilesStub)
        self._VAPI_OPERATION_IDS = {}


    def delete(self,
               port_mirroring_profile_id,
               ):
        """
        API will delete port mirroring profile. Mirroring from source to
        destination ports will be stopped.

        :type  port_mirroring_profile_id: :class:`str`
        :param port_mirroring_profile_id: Port Mirroring Profile Id (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete',
                            {
                            'port_mirroring_profile_id': port_mirroring_profile_id,
                            })

    def get(self,
            port_mirroring_profile_id,
            ):
        """
        API will return details of port mirroring profile.

        :type  port_mirroring_profile_id: :class:`str`
        :param port_mirroring_profile_id: Port Mirroring Profile Id (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.PortMirroringProfile`
        :return: com.vmware.nsx_policy.model.PortMirroringProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get',
                            {
                            'port_mirroring_profile_id': port_mirroring_profile_id,
                            })

    def list(self,
             cursor=None,
             included_fields=None,
             page_size=None,
             sort_ascending=None,
             sort_by=None,
             ):
        """
        API will list all port mirroring profiles group.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.PortMirroringProfileListResult`
        :return: com.vmware.nsx_policy.model.PortMirroringProfileListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list',
                            {
                            'cursor': cursor,
                            'included_fields': included_fields,
                            'page_size': page_size,
                            'sort_ascending': sort_ascending,
                            'sort_by': sort_by,
                            })

    def patch(self,
              port_mirroring_profile_id,
              port_mirroring_profile,
              ):
        """
        Create a new Port Mirroring Profile if the Port Mirroring Profile with
        given id does not already exist. If the Port Mirroring Profile with the
        given id already exists, patch with the existing Port Mirroring
        Profile. Realized entities of this API can be found using the path of
        monitoring profile binding map that is used to apply this profile.

        :type  port_mirroring_profile_id: :class:`str`
        :param port_mirroring_profile_id: Port Mirroring Profile Id (required)
        :type  port_mirroring_profile: :class:`com.vmware.nsx_policy.model_client.PortMirroringProfile`
        :param port_mirroring_profile: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch',
                            {
                            'port_mirroring_profile_id': port_mirroring_profile_id,
                            'port_mirroring_profile': port_mirroring_profile,
                            })

    def update(self,
               port_mirroring_profile_id,
               port_mirroring_profile,
               ):
        """
        Create or Replace port mirroring profile. Packets will be mirrored from
        source group, segment, port to destination group. Realized entities of
        this API can be found using the path of monitoring profile binding map
        that is used to apply this profile.

        :type  port_mirroring_profile_id: :class:`str`
        :param port_mirroring_profile_id: Port Mirroring Profiles Id (required)
        :type  port_mirroring_profile: :class:`com.vmware.nsx_policy.model_client.PortMirroringProfile`
        :param port_mirroring_profile: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.PortMirroringProfile`
        :return: com.vmware.nsx_policy.model.PortMirroringProfile
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update',
                            {
                            'port_mirroring_profile_id': port_mirroring_profile_id,
                            'port_mirroring_profile': port_mirroring_profile,
                            })
class Segments(VapiInterface):
    """
    
    """

    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.segments'
    """
    Identifier of the service in canonical form.
    """
    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _SegmentsStub)
        self._VAPI_OPERATION_IDS = {}


    def delete(self,
               segment_id,
               ):
        """
        Delete infra segment

        :type  segment_id: :class:`str`
        :param segment_id: Segment ID (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete',
                            {
                            'segment_id': segment_id,
                            })

    def delete_0(self,
                 segment_id,
                 ):
        """
        Force delete bypasses validations during segment deletion. This may
        result in an inconsistent connectivity.

        :type  segment_id: :class:`str`
        :param segment_id: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete_0',
                            {
                            'segment_id': segment_id,
                            })

    def get(self,
            segment_id,
            ):
        """
        Read infra segment

        :type  segment_id: :class:`str`
        :param segment_id: Segment ID (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.Segment`
        :return: com.vmware.nsx_policy.model.Segment
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get',
                            {
                            'segment_id': segment_id,
                            })

    def list(self,
             cursor=None,
             include_mark_for_delete_objects=None,
             included_fields=None,
             page_size=None,
             sort_ascending=None,
             sort_by=None,
             ):
        """
        Paginated list of all segments under infra.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.SegmentListResult`
        :return: com.vmware.nsx_policy.model.SegmentListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list',
                            {
                            'cursor': cursor,
                            'include_mark_for_delete_objects': include_mark_for_delete_objects,
                            'included_fields': included_fields,
                            'page_size': page_size,
                            'sort_ascending': sort_ascending,
                            'sort_by': sort_by,
                            })

    def patch(self,
              segment_id,
              segment,
              ):
        """
        If segment with the segment-id is not already present, create a new
        segment. If it already exists, update the segment with specified
        attributes.

        :type  segment_id: :class:`str`
        :param segment_id: Segment ID (required)
        :type  segment: :class:`com.vmware.nsx_policy.model_client.Segment`
        :param segment: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch',
                            {
                            'segment_id': segment_id,
                            'segment': segment,
                            })

    def update(self,
               segment_id,
               segment,
               ):
        """
        If segment with the segment-id is not already present, create a new
        segment. If it already exists, replace the segment with this object.

        :type  segment_id: :class:`str`
        :param segment_id: Segment ID (required)
        :type  segment: :class:`com.vmware.nsx_policy.model_client.Segment`
        :param segment: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.Segment`
        :return: com.vmware.nsx_policy.model.Segment
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update',
                            {
                            'segment_id': segment_id,
                            'segment': segment,
                            })
class Services(VapiInterface):
    """
    
    """

    _VAPI_SERVICE_ID = 'com.vmware.nsx_policy.infra.services'
    """
    Identifier of the service in canonical form.
    """
    def __init__(self, config):
        """
        :type  config: :class:`vmware.vapi.bindings.stub.StubConfiguration`
        :param config: Configuration to be used for creating the stub.
        """
        VapiInterface.__init__(self, config, _ServicesStub)
        self._VAPI_OPERATION_IDS = {}


    def delete(self,
               service_id,
               ):
        """
        Delete Service

        :type  service_id: :class:`str`
        :param service_id: Service ID (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('delete',
                            {
                            'service_id': service_id,
                            })

    def get(self,
            service_id,
            ):
        """
        Read a service

        :type  service_id: :class:`str`
        :param service_id: Service ID (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.Service`
        :return: com.vmware.nsx_policy.model.Service
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('get',
                            {
                            'service_id': service_id,
                            })

    def list(self,
             cursor=None,
             default_service=None,
             include_mark_for_delete_objects=None,
             included_fields=None,
             page_size=None,
             sort_ascending=None,
             sort_by=None,
             ):
        """
        Paginated list of Services for infra.

        :type  cursor: :class:`str` or ``None``
        :param cursor: Opaque cursor to be used for getting next page of records (supplied
            by current result page) (optional)
        :type  default_service: :class:`bool` or ``None``
        :param default_service: Fetch all default services (optional)
        :type  include_mark_for_delete_objects: :class:`bool` or ``None``
        :param include_mark_for_delete_objects: Include objects that are marked for deletion in results (optional,
            default to false)
        :type  included_fields: :class:`str` or ``None``
        :param included_fields: Comma separated list of fields that should be included in query
            result (optional)
        :type  page_size: :class:`long` or ``None``
        :param page_size: Maximum number of results to return in this page (server may return
            fewer) (optional, default to 1000)
        :type  sort_ascending: :class:`bool` or ``None``
        :param sort_ascending: (optional)
        :type  sort_by: :class:`str` or ``None``
        :param sort_by: Field by which records are sorted (optional)
        :rtype: :class:`com.vmware.nsx_policy.model_client.ServiceListResult`
        :return: com.vmware.nsx_policy.model.ServiceListResult
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('list',
                            {
                            'cursor': cursor,
                            'default_service': default_service,
                            'include_mark_for_delete_objects': include_mark_for_delete_objects,
                            'included_fields': included_fields,
                            'page_size': page_size,
                            'sort_ascending': sort_ascending,
                            'sort_by': sort_by,
                            })

    def patch(self,
              service_id,
              service,
              ):
        """
        Create a new service if a service with the given ID does not already
        exist. Creates new service entries if populated in the service. If a
        service with the given ID already exists, patch the service including
        the nested service entries.

        :type  service_id: :class:`str`
        :param service_id: Service ID (required)
        :type  service: :class:`com.vmware.nsx_policy.model_client.Service`
        :param service: (required)
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('patch',
                            {
                            'service_id': service_id,
                            'service': service,
                            })

    def update(self,
               service_id,
               service,
               ):
        """
        Create a new service if a service with the given ID does not already
        exist. Creates new service entries if populated in the service. If a
        service with the given ID already exists, update the service including
        the nested service entries. This is a full replace.

        :type  service_id: :class:`str`
        :param service_id: Service ID (required)
        :type  service: :class:`com.vmware.nsx_policy.model_client.Service`
        :param service: (required)
        :rtype: :class:`com.vmware.nsx_policy.model_client.Service`
        :return: com.vmware.nsx_policy.model.Service
        :raise: :class:`com.vmware.vapi.std.errors_client.ServiceUnavailable` 
             Service Unavailable
        :raise: :class:`com.vmware.vapi.std.errors_client.InvalidRequest` 
             Bad Request, Precondition Failed
        :raise: :class:`com.vmware.vapi.std.errors_client.InternalServerError` 
             Internal Server Error
        :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` 
             Forbidden
        :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` 
             Not Found
        """
        return self._invoke('update',
                            {
                            'service_id': service_id,
                            'service': service,
                            })
class _DhcpRelayConfigsStub(ApiInterfaceStub):
    def __init__(self, config):
        # properties for delete operation
        delete_input_type = type.StructType('operation-input', {
            'dhcp_relay_config_id': type.StringType(),
        })
        delete_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        delete_input_value_validator_list = [
        ]
        delete_output_validator_list = [
        ]
        delete_rest_metadata = OperationRestMetadata(
            http_method='DELETE',
            url_template='/policy/api/v1/infra/dhcp-relay-configs/{dhcp-relay-config-id}',
            path_variables={
                'dhcp_relay_config_id': 'dhcp-relay-config-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for get operation
        get_input_type = type.StructType('operation-input', {
            'dhcp_relay_config_id': type.StringType(),
        })
        get_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        get_input_value_validator_list = [
        ]
        get_output_validator_list = [
            HasFieldsOfValidator()
        ]
        get_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/dhcp-relay-configs/{dhcp-relay-config-id}',
            path_variables={
                'dhcp_relay_config_id': 'dhcp-relay-config-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for list operation
        list_input_type = type.StructType('operation-input', {
            'cursor': type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.BooleanType()),
            'included_fields': type.OptionalType(type.StringType()),
            'page_size': type.OptionalType(type.IntegerType()),
            'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType()),
        })
        list_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        list_input_value_validator_list = [
        ]
        list_output_validator_list = [
            HasFieldsOfValidator()
        ]
        list_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/dhcp-relay-configs',
            path_variables={
            },
            query_parameters={
                'cursor': 'cursor',
                'include_mark_for_delete_objects': 'include_mark_for_delete_objects',
                'included_fields': 'included_fields',
                'page_size': 'page_size',
                'sort_ascending': 'sort_ascending',
                'sort_by': 'sort_by',
            },
            content_type='application/json'
        )

        # properties for patch operation
        patch_input_type = type.StructType('operation-input', {
            'dhcp_relay_config_id': type.StringType(),
            'dhcp_relay_config': type.ReferenceType('com.vmware.nsx_policy.model_client', 'DhcpRelayConfig'),
        })
        patch_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        patch_input_value_validator_list = [
            HasFieldsOfValidator()
        ]
        patch_output_validator_list = [
        ]
        patch_rest_metadata = OperationRestMetadata(
            http_method='PATCH',
            url_template='/policy/api/v1/infra/dhcp-relay-configs/{dhcp-relay-config-id}',
            request_body_parameter='dhcp_relay_config',
            path_variables={
                'dhcp_relay_config_id': 'dhcp-relay-config-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for update operation
        update_input_type = type.StructType('operation-input', {
            'dhcp_relay_config_id': type.StringType(),
            'dhcp_relay_config': type.ReferenceType('com.vmware.nsx_policy.model_client', 'DhcpRelayConfig'),
        })
        update_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        update_input_value_validator_list = [
            HasFieldsOfValidator()
        ]
        update_output_validator_list = [
            HasFieldsOfValidator()
        ]
        update_rest_metadata = OperationRestMetadata(
            http_method='PUT',
            url_template='/policy/api/v1/infra/dhcp-relay-configs/{dhcp-relay-config-id}',
            request_body_parameter='dhcp_relay_config',
            path_variables={
                'dhcp_relay_config_id': 'dhcp-relay-config-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        operations = {
            'delete': {
                'input_type': delete_input_type,
                'output_type': type.VoidType(),
                'errors': delete_error_dict,
                'input_value_validator_list': delete_input_value_validator_list,
                'output_validator_list': delete_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'get': {
                'input_type': get_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'DhcpRelayConfig'),
                'errors': get_error_dict,
                'input_value_validator_list': get_input_value_validator_list,
                'output_validator_list': get_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'list': {
                'input_type': list_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'DhcpRelayConfigListResult'),
                'errors': list_error_dict,
                'input_value_validator_list': list_input_value_validator_list,
                'output_validator_list': list_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'patch': {
                'input_type': patch_input_type,
                'output_type': type.VoidType(),
                'errors': patch_error_dict,
                'input_value_validator_list': patch_input_value_validator_list,
                'output_validator_list': patch_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'update': {
                'input_type': update_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'DhcpRelayConfig'),
                'errors': update_error_dict,
                'input_value_validator_list': update_input_value_validator_list,
                'output_validator_list': update_output_validator_list,
                'task_type': TaskType.NONE,
            },
        }
        rest_metadata = {
            'delete': delete_rest_metadata,
            'get': get_rest_metadata,
            'list': list_rest_metadata,
            'patch': patch_rest_metadata,
            'update': update_rest_metadata,
        }
        ApiInterfaceStub.__init__(
            self, iface_name='com.vmware.nsx_policy.infra.dhcp_relay_configs',
            config=config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)

class _DhcpServerConfigsStub(ApiInterfaceStub):
    def __init__(self, config):
        # properties for delete operation
        delete_input_type = type.StructType('operation-input', {
            'dhcp_server_config_id': type.StringType(),
        })
        delete_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        delete_input_value_validator_list = [
        ]
        delete_output_validator_list = [
        ]
        delete_rest_metadata = OperationRestMetadata(
            http_method='DELETE',
            url_template='/policy/api/v1/infra/dhcp-server-configs/{dhcp-server-config-id}',
            path_variables={
                'dhcp_server_config_id': 'dhcp-server-config-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for get operation
        get_input_type = type.StructType('operation-input', {
            'dhcp_server_config_id': type.StringType(),
        })
        get_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        get_input_value_validator_list = [
        ]
        get_output_validator_list = [
            HasFieldsOfValidator()
        ]
        get_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/dhcp-server-configs/{dhcp-server-config-id}',
            path_variables={
                'dhcp_server_config_id': 'dhcp-server-config-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for list operation
        list_input_type = type.StructType('operation-input', {
            'cursor': type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.BooleanType()),
            'included_fields': type.OptionalType(type.StringType()),
            'page_size': type.OptionalType(type.IntegerType()),
            'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType()),
        })
        list_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        list_input_value_validator_list = [
        ]
        list_output_validator_list = [
            HasFieldsOfValidator()
        ]
        list_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/dhcp-server-configs',
            path_variables={
            },
            query_parameters={
                'cursor': 'cursor',
                'include_mark_for_delete_objects': 'include_mark_for_delete_objects',
                'included_fields': 'included_fields',
                'page_size': 'page_size',
                'sort_ascending': 'sort_ascending',
                'sort_by': 'sort_by',
            },
            content_type='application/json'
        )

        # properties for patch operation
        patch_input_type = type.StructType('operation-input', {
            'dhcp_server_config_id': type.StringType(),
            'dhcp_server_config': type.ReferenceType('com.vmware.nsx_policy.model_client', 'DhcpServerConfig'),
        })
        patch_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        patch_input_value_validator_list = [
            HasFieldsOfValidator()
        ]
        patch_output_validator_list = [
        ]
        patch_rest_metadata = OperationRestMetadata(
            http_method='PATCH',
            url_template='/policy/api/v1/infra/dhcp-server-configs/{dhcp-server-config-id}',
            request_body_parameter='dhcp_server_config',
            path_variables={
                'dhcp_server_config_id': 'dhcp-server-config-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for update operation
        update_input_type = type.StructType('operation-input', {
            'dhcp_server_config_id': type.StringType(),
            'dhcp_server_config': type.ReferenceType('com.vmware.nsx_policy.model_client', 'DhcpServerConfig'),
        })
        update_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        update_input_value_validator_list = [
            HasFieldsOfValidator()
        ]
        update_output_validator_list = [
            HasFieldsOfValidator()
        ]
        update_rest_metadata = OperationRestMetadata(
            http_method='PUT',
            url_template='/policy/api/v1/infra/dhcp-server-configs/{dhcp-server-config-id}',
            request_body_parameter='dhcp_server_config',
            path_variables={
                'dhcp_server_config_id': 'dhcp-server-config-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        operations = {
            'delete': {
                'input_type': delete_input_type,
                'output_type': type.VoidType(),
                'errors': delete_error_dict,
                'input_value_validator_list': delete_input_value_validator_list,
                'output_validator_list': delete_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'get': {
                'input_type': get_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'DhcpServerConfig'),
                'errors': get_error_dict,
                'input_value_validator_list': get_input_value_validator_list,
                'output_validator_list': get_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'list': {
                'input_type': list_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'DhcpServerConfigListResult'),
                'errors': list_error_dict,
                'input_value_validator_list': list_input_value_validator_list,
                'output_validator_list': list_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'patch': {
                'input_type': patch_input_type,
                'output_type': type.VoidType(),
                'errors': patch_error_dict,
                'input_value_validator_list': patch_input_value_validator_list,
                'output_validator_list': patch_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'update': {
                'input_type': update_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'DhcpServerConfig'),
                'errors': update_error_dict,
                'input_value_validator_list': update_input_value_validator_list,
                'output_validator_list': update_output_validator_list,
                'task_type': TaskType.NONE,
            },
        }
        rest_metadata = {
            'delete': delete_rest_metadata,
            'get': get_rest_metadata,
            'list': list_rest_metadata,
            'patch': patch_rest_metadata,
            'update': update_rest_metadata,
        }
        ApiInterfaceStub.__init__(
            self, iface_name='com.vmware.nsx_policy.infra.dhcp_server_configs',
            config=config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)

class _DnsForwarderZonesStub(ApiInterfaceStub):
    def __init__(self, config):
        # properties for delete operation
        delete_input_type = type.StructType('operation-input', {
            'dns_forwarder_zone_id': type.StringType(),
        })
        delete_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        delete_input_value_validator_list = [
        ]
        delete_output_validator_list = [
        ]
        delete_rest_metadata = OperationRestMetadata(
            http_method='DELETE',
            url_template='/policy/api/v1/infra/dns-forwarder-zones/{dns-forwarder-zone-id}',
            path_variables={
                'dns_forwarder_zone_id': 'dns-forwarder-zone-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for get operation
        get_input_type = type.StructType('operation-input', {
            'dns_forwarder_zone_id': type.StringType(),
        })
        get_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        get_input_value_validator_list = [
        ]
        get_output_validator_list = [
            HasFieldsOfValidator()
        ]
        get_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/dns-forwarder-zones/{dns-forwarder-zone-id}',
            path_variables={
                'dns_forwarder_zone_id': 'dns-forwarder-zone-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for list operation
        list_input_type = type.StructType('operation-input', {
            'cursor': type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.BooleanType()),
            'included_fields': type.OptionalType(type.StringType()),
            'page_size': type.OptionalType(type.IntegerType()),
            'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType()),
        })
        list_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        list_input_value_validator_list = [
        ]
        list_output_validator_list = [
            HasFieldsOfValidator()
        ]
        list_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/dns-forwarder-zones',
            path_variables={
            },
            query_parameters={
                'cursor': 'cursor',
                'include_mark_for_delete_objects': 'include_mark_for_delete_objects',
                'included_fields': 'included_fields',
                'page_size': 'page_size',
                'sort_ascending': 'sort_ascending',
                'sort_by': 'sort_by',
            },
            content_type='application/json'
        )

        # properties for patch operation
        patch_input_type = type.StructType('operation-input', {
            'dns_forwarder_zone_id': type.StringType(),
            'policy_dns_forwarder_zone': type.ReferenceType('com.vmware.nsx_policy.model_client', 'PolicyDnsForwarderZone'),
        })
        patch_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        patch_input_value_validator_list = [
            HasFieldsOfValidator()
        ]
        patch_output_validator_list = [
        ]
        patch_rest_metadata = OperationRestMetadata(
            http_method='PATCH',
            url_template='/policy/api/v1/infra/dns-forwarder-zones/{dns-forwarder-zone-id}',
            request_body_parameter='policy_dns_forwarder_zone',
            path_variables={
                'dns_forwarder_zone_id': 'dns-forwarder-zone-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for update operation
        update_input_type = type.StructType('operation-input', {
            'dns_forwarder_zone_id': type.StringType(),
            'policy_dns_forwarder_zone': type.ReferenceType('com.vmware.nsx_policy.model_client', 'PolicyDnsForwarderZone'),
        })
        update_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        update_input_value_validator_list = [
            HasFieldsOfValidator()
        ]
        update_output_validator_list = [
            HasFieldsOfValidator()
        ]
        update_rest_metadata = OperationRestMetadata(
            http_method='PUT',
            url_template='/policy/api/v1/infra/dns-forwarder-zones/{dns-forwarder-zone-id}',
            request_body_parameter='policy_dns_forwarder_zone',
            path_variables={
                'dns_forwarder_zone_id': 'dns-forwarder-zone-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        operations = {
            'delete': {
                'input_type': delete_input_type,
                'output_type': type.VoidType(),
                'errors': delete_error_dict,
                'input_value_validator_list': delete_input_value_validator_list,
                'output_validator_list': delete_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'get': {
                'input_type': get_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'PolicyDnsForwarderZone'),
                'errors': get_error_dict,
                'input_value_validator_list': get_input_value_validator_list,
                'output_validator_list': get_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'list': {
                'input_type': list_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'PolicyDnsForwarderZoneListResult'),
                'errors': list_error_dict,
                'input_value_validator_list': list_input_value_validator_list,
                'output_validator_list': list_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'patch': {
                'input_type': patch_input_type,
                'output_type': type.VoidType(),
                'errors': patch_error_dict,
                'input_value_validator_list': patch_input_value_validator_list,
                'output_validator_list': patch_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'update': {
                'input_type': update_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'PolicyDnsForwarderZone'),
                'errors': update_error_dict,
                'input_value_validator_list': update_input_value_validator_list,
                'output_validator_list': update_output_validator_list,
                'task_type': TaskType.NONE,
            },
        }
        rest_metadata = {
            'delete': delete_rest_metadata,
            'get': get_rest_metadata,
            'list': list_rest_metadata,
            'patch': patch_rest_metadata,
            'update': update_rest_metadata,
        }
        ApiInterfaceStub.__init__(
            self, iface_name='com.vmware.nsx_policy.infra.dns_forwarder_zones',
            config=config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)

class _DomainsStub(ApiInterfaceStub):
    def __init__(self, config):
        # properties for get operation
        get_input_type = type.StructType('operation-input', {
            'domain_id': type.StringType(),
        })
        get_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        get_input_value_validator_list = [
        ]
        get_output_validator_list = [
            HasFieldsOfValidator()
        ]
        get_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/domains/{domain-id}',
            path_variables={
                'domain_id': 'domain-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for list operation
        list_input_type = type.StructType('operation-input', {
            'cursor': type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.BooleanType()),
            'included_fields': type.OptionalType(type.StringType()),
            'page_size': type.OptionalType(type.IntegerType()),
            'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType()),
        })
        list_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        list_input_value_validator_list = [
        ]
        list_output_validator_list = [
            HasFieldsOfValidator()
        ]
        list_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/domains',
            path_variables={
            },
            query_parameters={
                'cursor': 'cursor',
                'include_mark_for_delete_objects': 'include_mark_for_delete_objects',
                'included_fields': 'included_fields',
                'page_size': 'page_size',
                'sort_ascending': 'sort_ascending',
                'sort_by': 'sort_by',
            },
            content_type='application/json'
        )

        operations = {
            'get': {
                'input_type': get_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'Domain'),
                'errors': get_error_dict,
                'input_value_validator_list': get_input_value_validator_list,
                'output_validator_list': get_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'list': {
                'input_type': list_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'DomainListResult'),
                'errors': list_error_dict,
                'input_value_validator_list': list_input_value_validator_list,
                'output_validator_list': list_output_validator_list,
                'task_type': TaskType.NONE,
            },
        }
        rest_metadata = {
            'get': get_rest_metadata,
            'list': list_rest_metadata,
        }
        ApiInterfaceStub.__init__(
            self, iface_name='com.vmware.nsx_policy.infra.domains',
            config=config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)

class _DraftsStub(ApiInterfaceStub):
    def __init__(self, config):
        # properties for abort operation
        abort_input_type = type.StructType('operation-input', {
            'draft_id': type.StringType(),
        })
        abort_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        abort_input_value_validator_list = [
        ]
        abort_output_validator_list = [
        ]
        abort_rest_metadata = OperationRestMetadata(
            http_method='POST',
            url_template='/policy/api/v1/infra/drafts/{draft-id}?action=abort',
            path_variables={
                'draft_id': 'draft-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for delete operation
        delete_input_type = type.StructType('operation-input', {
            'draft_id': type.StringType(),
        })
        delete_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        delete_input_value_validator_list = [
        ]
        delete_output_validator_list = [
        ]
        delete_rest_metadata = OperationRestMetadata(
            http_method='DELETE',
            url_template='/policy/api/v1/infra/drafts/{draft-id}',
            path_variables={
                'draft_id': 'draft-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for get operation
        get_input_type = type.StructType('operation-input', {
            'draft_id': type.StringType(),
        })
        get_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        get_input_value_validator_list = [
        ]
        get_output_validator_list = [
            HasFieldsOfValidator()
        ]
        get_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/drafts/{draft-id}',
            path_variables={
                'draft_id': 'draft-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for list operation
        list_input_type = type.StructType('operation-input', {
            'auto_drafts': type.OptionalType(type.BooleanType()),
            'cursor': type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.BooleanType()),
            'included_fields': type.OptionalType(type.StringType()),
            'page_size': type.OptionalType(type.IntegerType()),
            'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType()),
        })
        list_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        list_input_value_validator_list = [
        ]
        list_output_validator_list = [
            HasFieldsOfValidator()
        ]
        list_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/drafts',
            path_variables={
            },
            query_parameters={
                'auto_drafts': 'auto_drafts',
                'cursor': 'cursor',
                'include_mark_for_delete_objects': 'include_mark_for_delete_objects',
                'included_fields': 'included_fields',
                'page_size': 'page_size',
                'sort_ascending': 'sort_ascending',
                'sort_by': 'sort_by',
            },
            content_type='application/json'
        )

        # properties for patch operation
        patch_input_type = type.StructType('operation-input', {
            'draft_id': type.StringType(),
            'policy_draft': type.ReferenceType('com.vmware.nsx_policy.model_client', 'PolicyDraft'),
        })
        patch_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        patch_input_value_validator_list = [
            HasFieldsOfValidator()
        ]
        patch_output_validator_list = [
        ]
        patch_rest_metadata = OperationRestMetadata(
            http_method='PATCH',
            url_template='/policy/api/v1/infra/drafts/{draft-id}',
            request_body_parameter='policy_draft',
            path_variables={
                'draft_id': 'draft-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for publish operation
        publish_input_type = type.StructType('operation-input', {
            'draft_id': type.StringType(),
            'infra': type.ReferenceType('com.vmware.nsx_policy.model_client', 'Infra'),
        })
        publish_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        publish_input_value_validator_list = [
            HasFieldsOfValidator()
        ]
        publish_output_validator_list = [
        ]
        publish_rest_metadata = OperationRestMetadata(
            http_method='POST',
            url_template='/policy/api/v1/infra/drafts/{draft-id}?action=publish',
            request_body_parameter='infra',
            path_variables={
                'draft_id': 'draft-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for update operation
        update_input_type = type.StructType('operation-input', {
            'draft_id': type.StringType(),
            'policy_draft': type.ReferenceType('com.vmware.nsx_policy.model_client', 'PolicyDraft'),
        })
        update_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        update_input_value_validator_list = [
            HasFieldsOfValidator()
        ]
        update_output_validator_list = [
            HasFieldsOfValidator()
        ]
        update_rest_metadata = OperationRestMetadata(
            http_method='PUT',
            url_template='/policy/api/v1/infra/drafts/{draft-id}',
            request_body_parameter='policy_draft',
            path_variables={
                'draft_id': 'draft-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        operations = {
            'abort': {
                'input_type': abort_input_type,
                'output_type': type.VoidType(),
                'errors': abort_error_dict,
                'input_value_validator_list': abort_input_value_validator_list,
                'output_validator_list': abort_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'delete': {
                'input_type': delete_input_type,
                'output_type': type.VoidType(),
                'errors': delete_error_dict,
                'input_value_validator_list': delete_input_value_validator_list,
                'output_validator_list': delete_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'get': {
                'input_type': get_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'PolicyDraft'),
                'errors': get_error_dict,
                'input_value_validator_list': get_input_value_validator_list,
                'output_validator_list': get_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'list': {
                'input_type': list_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'PolicyDraftListResult'),
                'errors': list_error_dict,
                'input_value_validator_list': list_input_value_validator_list,
                'output_validator_list': list_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'patch': {
                'input_type': patch_input_type,
                'output_type': type.VoidType(),
                'errors': patch_error_dict,
                'input_value_validator_list': patch_input_value_validator_list,
                'output_validator_list': patch_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'publish': {
                'input_type': publish_input_type,
                'output_type': type.VoidType(),
                'errors': publish_error_dict,
                'input_value_validator_list': publish_input_value_validator_list,
                'output_validator_list': publish_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'update': {
                'input_type': update_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'PolicyDraft'),
                'errors': update_error_dict,
                'input_value_validator_list': update_input_value_validator_list,
                'output_validator_list': update_output_validator_list,
                'task_type': TaskType.NONE,
            },
        }
        rest_metadata = {
            'abort': abort_rest_metadata,
            'delete': delete_rest_metadata,
            'get': get_rest_metadata,
            'list': list_rest_metadata,
            'patch': patch_rest_metadata,
            'publish': publish_rest_metadata,
            'update': update_rest_metadata,
        }
        ApiInterfaceStub.__init__(
            self, iface_name='com.vmware.nsx_policy.infra.drafts',
            config=config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)

class _GroupAssociationsStub(ApiInterfaceStub):
    def __init__(self, config):
        # properties for list operation
        list_input_type = type.StructType('operation-input', {
            'intent_path': type.StringType(),
            'cursor': type.OptionalType(type.StringType()),
            'enforcement_point_path': type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.BooleanType()),
            'included_fields': type.OptionalType(type.StringType()),
            'page_size': type.OptionalType(type.IntegerType()),
            'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType()),
        })
        list_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        list_input_value_validator_list = [
        ]
        list_output_validator_list = [
        ]
        list_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/group-associations',
            path_variables={
            },
            query_parameters={
                'intent_path': 'intent_path',
                'cursor': 'cursor',
                'enforcement_point_path': 'enforcement_point_path',
                'include_mark_for_delete_objects': 'include_mark_for_delete_objects',
                'included_fields': 'included_fields',
                'page_size': 'page_size',
                'sort_ascending': 'sort_ascending',
                'sort_by': 'sort_by',
            },
            content_type='application/json'
        )

        operations = {
            'list': {
                'input_type': list_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'PolicyResourceReferenceForEPListResult'),
                'errors': list_error_dict,
                'input_value_validator_list': list_input_value_validator_list,
                'output_validator_list': list_output_validator_list,
                'task_type': TaskType.NONE,
            },
        }
        rest_metadata = {
            'list': list_rest_metadata,
        }
        ApiInterfaceStub.__init__(
            self, iface_name='com.vmware.nsx_policy.infra.group_associations',
            config=config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)

class _IpfixCollectorProfilesStub(ApiInterfaceStub):
    def __init__(self, config):
        # properties for delete operation
        delete_input_type = type.StructType('operation-input', {
            'ipfix_collector_profile_id': type.StringType(),
        })
        delete_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        delete_input_value_validator_list = [
        ]
        delete_output_validator_list = [
        ]
        delete_rest_metadata = OperationRestMetadata(
            http_method='DELETE',
            url_template='/policy/api/v1/infra/ipfix-collector-profiles/{ipfix-collector-profile-id}',
            path_variables={
                'ipfix_collector_profile_id': 'ipfix-collector-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for get operation
        get_input_type = type.StructType('operation-input', {
            'ipfix_collector_profile_id': type.StringType(),
        })
        get_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        get_input_value_validator_list = [
        ]
        get_output_validator_list = [
            HasFieldsOfValidator()
        ]
        get_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/ipfix-collector-profiles/{ipfix-collector-profile-id}',
            path_variables={
                'ipfix_collector_profile_id': 'ipfix-collector-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for list operation
        list_input_type = type.StructType('operation-input', {
            'cursor': type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.BooleanType()),
            'included_fields': type.OptionalType(type.StringType()),
            'page_size': type.OptionalType(type.IntegerType()),
            'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType()),
        })
        list_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        list_input_value_validator_list = [
        ]
        list_output_validator_list = [
            HasFieldsOfValidator()
        ]
        list_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/ipfix-collector-profiles',
            path_variables={
            },
            query_parameters={
                'cursor': 'cursor',
                'include_mark_for_delete_objects': 'include_mark_for_delete_objects',
                'included_fields': 'included_fields',
                'page_size': 'page_size',
                'sort_ascending': 'sort_ascending',
                'sort_by': 'sort_by',
            },
            content_type='application/json'
        )

        # properties for patch operation
        patch_input_type = type.StructType('operation-input', {
            'ipfix_collector_profile_id': type.StringType(),
            'i_PFIX_collector_profile': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPFIXCollectorProfile'),
        })
        patch_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        patch_input_value_validator_list = [
            HasFieldsOfValidator()
        ]
        patch_output_validator_list = [
        ]
        patch_rest_metadata = OperationRestMetadata(
            http_method='PATCH',
            url_template='/policy/api/v1/infra/ipfix-collector-profiles/{ipfix-collector-profile-id}',
            request_body_parameter='i_PFIX_collector_profile',
            path_variables={
                'ipfix_collector_profile_id': 'ipfix-collector-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for update operation
        update_input_type = type.StructType('operation-input', {
            'ipfix_collector_profile_id': type.StringType(),
            'i_PFIX_collector_profile': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPFIXCollectorProfile'),
        })
        update_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        update_input_value_validator_list = [
            HasFieldsOfValidator()
        ]
        update_output_validator_list = [
            HasFieldsOfValidator()
        ]
        update_rest_metadata = OperationRestMetadata(
            http_method='PUT',
            url_template='/policy/api/v1/infra/ipfix-collector-profiles/{ipfix-collector-profile-id}',
            request_body_parameter='i_PFIX_collector_profile',
            path_variables={
                'ipfix_collector_profile_id': 'ipfix-collector-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        operations = {
            'delete': {
                'input_type': delete_input_type,
                'output_type': type.VoidType(),
                'errors': delete_error_dict,
                'input_value_validator_list': delete_input_value_validator_list,
                'output_validator_list': delete_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'get': {
                'input_type': get_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPFIXCollectorProfile'),
                'errors': get_error_dict,
                'input_value_validator_list': get_input_value_validator_list,
                'output_validator_list': get_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'list': {
                'input_type': list_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPFIXCollectorProfileListResult'),
                'errors': list_error_dict,
                'input_value_validator_list': list_input_value_validator_list,
                'output_validator_list': list_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'patch': {
                'input_type': patch_input_type,
                'output_type': type.VoidType(),
                'errors': patch_error_dict,
                'input_value_validator_list': patch_input_value_validator_list,
                'output_validator_list': patch_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'update': {
                'input_type': update_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPFIXCollectorProfile'),
                'errors': update_error_dict,
                'input_value_validator_list': update_input_value_validator_list,
                'output_validator_list': update_output_validator_list,
                'task_type': TaskType.NONE,
            },
        }
        rest_metadata = {
            'delete': delete_rest_metadata,
            'get': get_rest_metadata,
            'list': list_rest_metadata,
            'patch': patch_rest_metadata,
            'update': update_rest_metadata,
        }
        ApiInterfaceStub.__init__(
            self, iface_name='com.vmware.nsx_policy.infra.ipfix_collector_profiles',
            config=config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)

class _IpfixDfwCollectorProfilesStub(ApiInterfaceStub):
    def __init__(self, config):
        # properties for delete operation
        delete_input_type = type.StructType('operation-input', {
            'ipfix_dfw_collector_profile_id': type.StringType(),
        })
        delete_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        delete_input_value_validator_list = [
        ]
        delete_output_validator_list = [
        ]
        delete_rest_metadata = OperationRestMetadata(
            http_method='DELETE',
            url_template='/policy/api/v1/infra/ipfix-dfw-collector-profiles/{ipfix-dfw-collector-profile-id}',
            path_variables={
                'ipfix_dfw_collector_profile_id': 'ipfix-dfw-collector-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for get operation
        get_input_type = type.StructType('operation-input', {
            'ipfix_dfw_collector_profile_id': type.StringType(),
        })
        get_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        get_input_value_validator_list = [
        ]
        get_output_validator_list = [
            HasFieldsOfValidator()
        ]
        get_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/ipfix-dfw-collector-profiles/{ipfix-dfw-collector-profile-id}',
            path_variables={
                'ipfix_dfw_collector_profile_id': 'ipfix-dfw-collector-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for list operation
        list_input_type = type.StructType('operation-input', {
            'cursor': type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.BooleanType()),
            'included_fields': type.OptionalType(type.StringType()),
            'page_size': type.OptionalType(type.IntegerType()),
            'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType()),
        })
        list_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        list_input_value_validator_list = [
        ]
        list_output_validator_list = [
            HasFieldsOfValidator()
        ]
        list_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/ipfix-dfw-collector-profiles',
            path_variables={
            },
            query_parameters={
                'cursor': 'cursor',
                'include_mark_for_delete_objects': 'include_mark_for_delete_objects',
                'included_fields': 'included_fields',
                'page_size': 'page_size',
                'sort_ascending': 'sort_ascending',
                'sort_by': 'sort_by',
            },
            content_type='application/json'
        )

        # properties for patch operation
        patch_input_type = type.StructType('operation-input', {
            'ipfix_dfw_collector_profile_id': type.StringType(),
            'i_PFIXDFW_collector_profile': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPFIXDFWCollectorProfile'),
        })
        patch_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        patch_input_value_validator_list = [
            HasFieldsOfValidator()
        ]
        patch_output_validator_list = [
        ]
        patch_rest_metadata = OperationRestMetadata(
            http_method='PATCH',
            url_template='/policy/api/v1/infra/ipfix-dfw-collector-profiles/{ipfix-dfw-collector-profile-id}',
            request_body_parameter='i_PFIXDFW_collector_profile',
            path_variables={
                'ipfix_dfw_collector_profile_id': 'ipfix-dfw-collector-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for update operation
        update_input_type = type.StructType('operation-input', {
            'ipfix_dfw_collector_profile_id': type.StringType(),
            'i_PFIXDFW_collector_profile': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPFIXDFWCollectorProfile'),
        })
        update_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        update_input_value_validator_list = [
            HasFieldsOfValidator()
        ]
        update_output_validator_list = [
            HasFieldsOfValidator()
        ]
        update_rest_metadata = OperationRestMetadata(
            http_method='PUT',
            url_template='/policy/api/v1/infra/ipfix-dfw-collector-profiles/{ipfix-dfw-collector-profile-id}',
            request_body_parameter='i_PFIXDFW_collector_profile',
            path_variables={
                'ipfix_dfw_collector_profile_id': 'ipfix-dfw-collector-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        operations = {
            'delete': {
                'input_type': delete_input_type,
                'output_type': type.VoidType(),
                'errors': delete_error_dict,
                'input_value_validator_list': delete_input_value_validator_list,
                'output_validator_list': delete_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'get': {
                'input_type': get_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPFIXDFWCollectorProfile'),
                'errors': get_error_dict,
                'input_value_validator_list': get_input_value_validator_list,
                'output_validator_list': get_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'list': {
                'input_type': list_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPFIXDFWCollectorProfileListResult'),
                'errors': list_error_dict,
                'input_value_validator_list': list_input_value_validator_list,
                'output_validator_list': list_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'patch': {
                'input_type': patch_input_type,
                'output_type': type.VoidType(),
                'errors': patch_error_dict,
                'input_value_validator_list': patch_input_value_validator_list,
                'output_validator_list': patch_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'update': {
                'input_type': update_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPFIXDFWCollectorProfile'),
                'errors': update_error_dict,
                'input_value_validator_list': update_input_value_validator_list,
                'output_validator_list': update_output_validator_list,
                'task_type': TaskType.NONE,
            },
        }
        rest_metadata = {
            'delete': delete_rest_metadata,
            'get': get_rest_metadata,
            'list': list_rest_metadata,
            'patch': patch_rest_metadata,
            'update': update_rest_metadata,
        }
        ApiInterfaceStub.__init__(
            self, iface_name='com.vmware.nsx_policy.infra.ipfix_dfw_collector_profiles',
            config=config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)

class _IpfixDfwProfilesStub(ApiInterfaceStub):
    def __init__(self, config):
        # properties for delete operation
        delete_input_type = type.StructType('operation-input', {
            'ipfix_dfw_profile_id': type.StringType(),
        })
        delete_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        delete_input_value_validator_list = [
        ]
        delete_output_validator_list = [
        ]
        delete_rest_metadata = OperationRestMetadata(
            http_method='DELETE',
            url_template='/policy/api/v1/infra/ipfix-dfw-profiles/{ipfix-dfw-profile-id}',
            path_variables={
                'ipfix_dfw_profile_id': 'ipfix-dfw-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for get operation
        get_input_type = type.StructType('operation-input', {
            'ipfix_dfw_profile_id': type.StringType(),
        })
        get_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        get_input_value_validator_list = [
        ]
        get_output_validator_list = [
            HasFieldsOfValidator()
        ]
        get_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/ipfix-dfw-profiles/{ipfix-dfw-profile-id}',
            path_variables={
                'ipfix_dfw_profile_id': 'ipfix-dfw-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for list operation
        list_input_type = type.StructType('operation-input', {
            'cursor': type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.BooleanType()),
            'included_fields': type.OptionalType(type.StringType()),
            'page_size': type.OptionalType(type.IntegerType()),
            'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType()),
        })
        list_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        list_input_value_validator_list = [
        ]
        list_output_validator_list = [
            HasFieldsOfValidator()
        ]
        list_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/ipfix-dfw-profiles',
            path_variables={
            },
            query_parameters={
                'cursor': 'cursor',
                'include_mark_for_delete_objects': 'include_mark_for_delete_objects',
                'included_fields': 'included_fields',
                'page_size': 'page_size',
                'sort_ascending': 'sort_ascending',
                'sort_by': 'sort_by',
            },
            content_type='application/json'
        )

        # properties for patch operation
        patch_input_type = type.StructType('operation-input', {
            'ipfix_dfw_profile_id': type.StringType(),
            'i_PFIXDFW_profile': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPFIXDFWProfile'),
        })
        patch_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        patch_input_value_validator_list = [
            HasFieldsOfValidator()
        ]
        patch_output_validator_list = [
        ]
        patch_rest_metadata = OperationRestMetadata(
            http_method='PATCH',
            url_template='/policy/api/v1/infra/ipfix-dfw-profiles/{ipfix-dfw-profile-id}',
            request_body_parameter='i_PFIXDFW_profile',
            path_variables={
                'ipfix_dfw_profile_id': 'ipfix-dfw-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for update operation
        update_input_type = type.StructType('operation-input', {
            'ipfix_dfw_profile_id': type.StringType(),
            'i_PFIXDFW_profile': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPFIXDFWProfile'),
        })
        update_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        update_input_value_validator_list = [
            HasFieldsOfValidator()
        ]
        update_output_validator_list = [
            HasFieldsOfValidator()
        ]
        update_rest_metadata = OperationRestMetadata(
            http_method='PUT',
            url_template='/policy/api/v1/infra/ipfix-dfw-profiles/{ipfix-dfw-profile-id}',
            request_body_parameter='i_PFIXDFW_profile',
            path_variables={
                'ipfix_dfw_profile_id': 'ipfix-dfw-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        operations = {
            'delete': {
                'input_type': delete_input_type,
                'output_type': type.VoidType(),
                'errors': delete_error_dict,
                'input_value_validator_list': delete_input_value_validator_list,
                'output_validator_list': delete_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'get': {
                'input_type': get_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPFIXDFWProfile'),
                'errors': get_error_dict,
                'input_value_validator_list': get_input_value_validator_list,
                'output_validator_list': get_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'list': {
                'input_type': list_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPFIXDFWProfileListResult'),
                'errors': list_error_dict,
                'input_value_validator_list': list_input_value_validator_list,
                'output_validator_list': list_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'patch': {
                'input_type': patch_input_type,
                'output_type': type.VoidType(),
                'errors': patch_error_dict,
                'input_value_validator_list': patch_input_value_validator_list,
                'output_validator_list': patch_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'update': {
                'input_type': update_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPFIXDFWProfile'),
                'errors': update_error_dict,
                'input_value_validator_list': update_input_value_validator_list,
                'output_validator_list': update_output_validator_list,
                'task_type': TaskType.NONE,
            },
        }
        rest_metadata = {
            'delete': delete_rest_metadata,
            'get': get_rest_metadata,
            'list': list_rest_metadata,
            'patch': patch_rest_metadata,
            'update': update_rest_metadata,
        }
        ApiInterfaceStub.__init__(
            self, iface_name='com.vmware.nsx_policy.infra.ipfix_dfw_profiles',
            config=config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)

class _IpfixL2CollectorProfilesStub(ApiInterfaceStub):
    def __init__(self, config):
        # properties for delete operation
        delete_input_type = type.StructType('operation-input', {
            'ipfix_l2_collector_profile_id': type.StringType(),
        })
        delete_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        delete_input_value_validator_list = [
        ]
        delete_output_validator_list = [
        ]
        delete_rest_metadata = OperationRestMetadata(
            http_method='DELETE',
            url_template='/policy/api/v1/infra/ipfix-l2-collector-profiles/{ipfix-l2-collector-profile-id}',
            path_variables={
                'ipfix_l2_collector_profile_id': 'ipfix-l2-collector-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for get operation
        get_input_type = type.StructType('operation-input', {
            'ipfix_l2_collector_profile_id': type.StringType(),
        })
        get_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        get_input_value_validator_list = [
        ]
        get_output_validator_list = [
            HasFieldsOfValidator()
        ]
        get_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/ipfix-l2-collector-profiles/{ipfix-l2-collector-profile-id}',
            path_variables={
                'ipfix_l2_collector_profile_id': 'ipfix-l2-collector-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for list operation
        list_input_type = type.StructType('operation-input', {
            'cursor': type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.BooleanType()),
            'included_fields': type.OptionalType(type.StringType()),
            'page_size': type.OptionalType(type.IntegerType()),
            'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType()),
        })
        list_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        list_input_value_validator_list = [
        ]
        list_output_validator_list = [
            HasFieldsOfValidator()
        ]
        list_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/ipfix-l2-collector-profiles',
            path_variables={
            },
            query_parameters={
                'cursor': 'cursor',
                'include_mark_for_delete_objects': 'include_mark_for_delete_objects',
                'included_fields': 'included_fields',
                'page_size': 'page_size',
                'sort_ascending': 'sort_ascending',
                'sort_by': 'sort_by',
            },
            content_type='application/json'
        )

        # properties for patch operation
        patch_input_type = type.StructType('operation-input', {
            'ipfix_l2_collector_profile_id': type.StringType(),
            'i_PFIX_l2_collector_profile': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPFIXL2CollectorProfile'),
        })
        patch_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        patch_input_value_validator_list = [
            HasFieldsOfValidator()
        ]
        patch_output_validator_list = [
        ]
        patch_rest_metadata = OperationRestMetadata(
            http_method='PATCH',
            url_template='/policy/api/v1/infra/ipfix-l2-collector-profiles/{ipfix-l2-collector-profile-id}',
            request_body_parameter='i_PFIX_l2_collector_profile',
            path_variables={
                'ipfix_l2_collector_profile_id': 'ipfix-l2-collector-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for update operation
        update_input_type = type.StructType('operation-input', {
            'ipfix_l2_collector_profile_id': type.StringType(),
            'i_PFIX_l2_collector_profile': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPFIXL2CollectorProfile'),
        })
        update_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        update_input_value_validator_list = [
            HasFieldsOfValidator()
        ]
        update_output_validator_list = [
            HasFieldsOfValidator()
        ]
        update_rest_metadata = OperationRestMetadata(
            http_method='PUT',
            url_template='/policy/api/v1/infra/ipfix-l2-collector-profiles/{ipfix-l2-collector-profile-id}',
            request_body_parameter='i_PFIX_l2_collector_profile',
            path_variables={
                'ipfix_l2_collector_profile_id': 'ipfix-l2-collector-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        operations = {
            'delete': {
                'input_type': delete_input_type,
                'output_type': type.VoidType(),
                'errors': delete_error_dict,
                'input_value_validator_list': delete_input_value_validator_list,
                'output_validator_list': delete_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'get': {
                'input_type': get_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPFIXL2CollectorProfile'),
                'errors': get_error_dict,
                'input_value_validator_list': get_input_value_validator_list,
                'output_validator_list': get_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'list': {
                'input_type': list_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPFIXL2CollectorProfileListResult'),
                'errors': list_error_dict,
                'input_value_validator_list': list_input_value_validator_list,
                'output_validator_list': list_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'patch': {
                'input_type': patch_input_type,
                'output_type': type.VoidType(),
                'errors': patch_error_dict,
                'input_value_validator_list': patch_input_value_validator_list,
                'output_validator_list': patch_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'update': {
                'input_type': update_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPFIXL2CollectorProfile'),
                'errors': update_error_dict,
                'input_value_validator_list': update_input_value_validator_list,
                'output_validator_list': update_output_validator_list,
                'task_type': TaskType.NONE,
            },
        }
        rest_metadata = {
            'delete': delete_rest_metadata,
            'get': get_rest_metadata,
            'list': list_rest_metadata,
            'patch': patch_rest_metadata,
            'update': update_rest_metadata,
        }
        ApiInterfaceStub.__init__(
            self, iface_name='com.vmware.nsx_policy.infra.ipfix_l2_collector_profiles',
            config=config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)

class _IpfixL2ProfilesStub(ApiInterfaceStub):
    def __init__(self, config):
        # properties for delete operation
        delete_input_type = type.StructType('operation-input', {
            'ipfix_l2_profile_id': type.StringType(),
        })
        delete_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        delete_input_value_validator_list = [
        ]
        delete_output_validator_list = [
        ]
        delete_rest_metadata = OperationRestMetadata(
            http_method='DELETE',
            url_template='/policy/api/v1/infra/ipfix-l2-profiles/{ipfix-l2-profile-id}',
            path_variables={
                'ipfix_l2_profile_id': 'ipfix-l2-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for get operation
        get_input_type = type.StructType('operation-input', {
            'ipfix_l2_profile_id': type.StringType(),
        })
        get_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        get_input_value_validator_list = [
        ]
        get_output_validator_list = [
            HasFieldsOfValidator()
        ]
        get_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/ipfix-l2-profiles/{ipfix-l2-profile-id}',
            path_variables={
                'ipfix_l2_profile_id': 'ipfix-l2-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for list operation
        list_input_type = type.StructType('operation-input', {
            'cursor': type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.BooleanType()),
            'included_fields': type.OptionalType(type.StringType()),
            'page_size': type.OptionalType(type.IntegerType()),
            'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType()),
        })
        list_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        list_input_value_validator_list = [
        ]
        list_output_validator_list = [
            HasFieldsOfValidator()
        ]
        list_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/ipfix-l2-profiles',
            path_variables={
            },
            query_parameters={
                'cursor': 'cursor',
                'include_mark_for_delete_objects': 'include_mark_for_delete_objects',
                'included_fields': 'included_fields',
                'page_size': 'page_size',
                'sort_ascending': 'sort_ascending',
                'sort_by': 'sort_by',
            },
            content_type='application/json'
        )

        # properties for patch operation
        patch_input_type = type.StructType('operation-input', {
            'ipfix_l2_profile_id': type.StringType(),
            'i_PFIX_l2_profile': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPFIXL2Profile'),
        })
        patch_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        patch_input_value_validator_list = [
            HasFieldsOfValidator()
        ]
        patch_output_validator_list = [
        ]
        patch_rest_metadata = OperationRestMetadata(
            http_method='PATCH',
            url_template='/policy/api/v1/infra/ipfix-l2-profiles/{ipfix-l2-profile-id}',
            request_body_parameter='i_PFIX_l2_profile',
            path_variables={
                'ipfix_l2_profile_id': 'ipfix-l2-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for update operation
        update_input_type = type.StructType('operation-input', {
            'ipfix_l2_profile_id': type.StringType(),
            'i_PFIX_l2_profile': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPFIXL2Profile'),
        })
        update_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        update_input_value_validator_list = [
            HasFieldsOfValidator()
        ]
        update_output_validator_list = [
            HasFieldsOfValidator()
        ]
        update_rest_metadata = OperationRestMetadata(
            http_method='PUT',
            url_template='/policy/api/v1/infra/ipfix-l2-profiles/{ipfix-l2-profile-id}',
            request_body_parameter='i_PFIX_l2_profile',
            path_variables={
                'ipfix_l2_profile_id': 'ipfix-l2-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        operations = {
            'delete': {
                'input_type': delete_input_type,
                'output_type': type.VoidType(),
                'errors': delete_error_dict,
                'input_value_validator_list': delete_input_value_validator_list,
                'output_validator_list': delete_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'get': {
                'input_type': get_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPFIXL2Profile'),
                'errors': get_error_dict,
                'input_value_validator_list': get_input_value_validator_list,
                'output_validator_list': get_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'list': {
                'input_type': list_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPFIXL2ProfileListResult'),
                'errors': list_error_dict,
                'input_value_validator_list': list_input_value_validator_list,
                'output_validator_list': list_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'patch': {
                'input_type': patch_input_type,
                'output_type': type.VoidType(),
                'errors': patch_error_dict,
                'input_value_validator_list': patch_input_value_validator_list,
                'output_validator_list': patch_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'update': {
                'input_type': update_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPFIXL2Profile'),
                'errors': update_error_dict,
                'input_value_validator_list': update_input_value_validator_list,
                'output_validator_list': update_output_validator_list,
                'task_type': TaskType.NONE,
            },
        }
        rest_metadata = {
            'delete': delete_rest_metadata,
            'get': get_rest_metadata,
            'list': list_rest_metadata,
            'patch': patch_rest_metadata,
            'update': update_rest_metadata,
        }
        ApiInterfaceStub.__init__(
            self, iface_name='com.vmware.nsx_policy.infra.ipfix_l2_profiles',
            config=config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)

class _IpsecVpnDpdProfilesStub(ApiInterfaceStub):
    def __init__(self, config):
        # properties for delete operation
        delete_input_type = type.StructType('operation-input', {
            'dpd_profile_id': type.StringType(),
        })
        delete_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        delete_input_value_validator_list = [
        ]
        delete_output_validator_list = [
        ]
        delete_rest_metadata = OperationRestMetadata(
            http_method='DELETE',
            url_template='/policy/api/v1/infra/ipsec-vpn-dpd-profiles/{dpd-profile-id}',
            path_variables={
                'dpd_profile_id': 'dpd-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for get operation
        get_input_type = type.StructType('operation-input', {
            'dpd_profile_id': type.StringType(),
        })
        get_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        get_input_value_validator_list = [
        ]
        get_output_validator_list = [
            HasFieldsOfValidator()
        ]
        get_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/ipsec-vpn-dpd-profiles/{dpd-profile-id}',
            path_variables={
                'dpd_profile_id': 'dpd-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for list operation
        list_input_type = type.StructType('operation-input', {
            'cursor': type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.BooleanType()),
            'included_fields': type.OptionalType(type.StringType()),
            'page_size': type.OptionalType(type.IntegerType()),
            'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType()),
        })
        list_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        list_input_value_validator_list = [
        ]
        list_output_validator_list = [
            HasFieldsOfValidator()
        ]
        list_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/ipsec-vpn-dpd-profiles',
            path_variables={
            },
            query_parameters={
                'cursor': 'cursor',
                'include_mark_for_delete_objects': 'include_mark_for_delete_objects',
                'included_fields': 'included_fields',
                'page_size': 'page_size',
                'sort_ascending': 'sort_ascending',
                'sort_by': 'sort_by',
            },
            content_type='application/json'
        )

        # properties for patch operation
        patch_input_type = type.StructType('operation-input', {
            'dpd_profile_id': type.StringType(),
            'ip_sec_vpn_dpd_profile': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPSecVpnDpdProfile'),
        })
        patch_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        patch_input_value_validator_list = [
            HasFieldsOfValidator()
        ]
        patch_output_validator_list = [
        ]
        patch_rest_metadata = OperationRestMetadata(
            http_method='PATCH',
            url_template='/policy/api/v1/infra/ipsec-vpn-dpd-profiles/{dpd-profile-id}',
            request_body_parameter='ip_sec_vpn_dpd_profile',
            path_variables={
                'dpd_profile_id': 'dpd-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for update operation
        update_input_type = type.StructType('operation-input', {
            'dpd_profile_id': type.StringType(),
            'ip_sec_vpn_dpd_profile': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPSecVpnDpdProfile'),
        })
        update_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        update_input_value_validator_list = [
            HasFieldsOfValidator()
        ]
        update_output_validator_list = [
            HasFieldsOfValidator()
        ]
        update_rest_metadata = OperationRestMetadata(
            http_method='PUT',
            url_template='/policy/api/v1/infra/ipsec-vpn-dpd-profiles/{dpd-profile-id}',
            request_body_parameter='ip_sec_vpn_dpd_profile',
            path_variables={
                'dpd_profile_id': 'dpd-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        operations = {
            'delete': {
                'input_type': delete_input_type,
                'output_type': type.VoidType(),
                'errors': delete_error_dict,
                'input_value_validator_list': delete_input_value_validator_list,
                'output_validator_list': delete_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'get': {
                'input_type': get_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPSecVpnDpdProfile'),
                'errors': get_error_dict,
                'input_value_validator_list': get_input_value_validator_list,
                'output_validator_list': get_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'list': {
                'input_type': list_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPSecVpnDpdProfileListResult'),
                'errors': list_error_dict,
                'input_value_validator_list': list_input_value_validator_list,
                'output_validator_list': list_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'patch': {
                'input_type': patch_input_type,
                'output_type': type.VoidType(),
                'errors': patch_error_dict,
                'input_value_validator_list': patch_input_value_validator_list,
                'output_validator_list': patch_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'update': {
                'input_type': update_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPSecVpnDpdProfile'),
                'errors': update_error_dict,
                'input_value_validator_list': update_input_value_validator_list,
                'output_validator_list': update_output_validator_list,
                'task_type': TaskType.NONE,
            },
        }
        rest_metadata = {
            'delete': delete_rest_metadata,
            'get': get_rest_metadata,
            'list': list_rest_metadata,
            'patch': patch_rest_metadata,
            'update': update_rest_metadata,
        }
        ApiInterfaceStub.__init__(
            self, iface_name='com.vmware.nsx_policy.infra.ipsec_vpn_dpd_profiles',
            config=config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)

class _IpsecVpnIkeProfilesStub(ApiInterfaceStub):
    def __init__(self, config):
        # properties for delete operation
        delete_input_type = type.StructType('operation-input', {
            'ike_profile_id': type.StringType(),
        })
        delete_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        delete_input_value_validator_list = [
        ]
        delete_output_validator_list = [
        ]
        delete_rest_metadata = OperationRestMetadata(
            http_method='DELETE',
            url_template='/policy/api/v1/infra/ipsec-vpn-ike-profiles/{ike-profile-id}',
            path_variables={
                'ike_profile_id': 'ike-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for get operation
        get_input_type = type.StructType('operation-input', {
            'ike_profile_id': type.StringType(),
        })
        get_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        get_input_value_validator_list = [
        ]
        get_output_validator_list = [
            HasFieldsOfValidator()
        ]
        get_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/ipsec-vpn-ike-profiles/{ike-profile-id}',
            path_variables={
                'ike_profile_id': 'ike-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for list operation
        list_input_type = type.StructType('operation-input', {
            'cursor': type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.BooleanType()),
            'included_fields': type.OptionalType(type.StringType()),
            'page_size': type.OptionalType(type.IntegerType()),
            'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType()),
        })
        list_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        list_input_value_validator_list = [
        ]
        list_output_validator_list = [
            HasFieldsOfValidator()
        ]
        list_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/ipsec-vpn-ike-profiles',
            path_variables={
            },
            query_parameters={
                'cursor': 'cursor',
                'include_mark_for_delete_objects': 'include_mark_for_delete_objects',
                'included_fields': 'included_fields',
                'page_size': 'page_size',
                'sort_ascending': 'sort_ascending',
                'sort_by': 'sort_by',
            },
            content_type='application/json'
        )

        # properties for patch operation
        patch_input_type = type.StructType('operation-input', {
            'ike_profile_id': type.StringType(),
            'ip_sec_vpn_ike_profile': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPSecVpnIkeProfile'),
        })
        patch_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        patch_input_value_validator_list = [
            HasFieldsOfValidator()
        ]
        patch_output_validator_list = [
        ]
        patch_rest_metadata = OperationRestMetadata(
            http_method='PATCH',
            url_template='/policy/api/v1/infra/ipsec-vpn-ike-profiles/{ike-profile-id}',
            request_body_parameter='ip_sec_vpn_ike_profile',
            path_variables={
                'ike_profile_id': 'ike-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for update operation
        update_input_type = type.StructType('operation-input', {
            'ike_profile_id': type.StringType(),
            'ip_sec_vpn_ike_profile': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPSecVpnIkeProfile'),
        })
        update_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        update_input_value_validator_list = [
            HasFieldsOfValidator()
        ]
        update_output_validator_list = [
            HasFieldsOfValidator()
        ]
        update_rest_metadata = OperationRestMetadata(
            http_method='PUT',
            url_template='/policy/api/v1/infra/ipsec-vpn-ike-profiles/{ike-profile-id}',
            request_body_parameter='ip_sec_vpn_ike_profile',
            path_variables={
                'ike_profile_id': 'ike-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        operations = {
            'delete': {
                'input_type': delete_input_type,
                'output_type': type.VoidType(),
                'errors': delete_error_dict,
                'input_value_validator_list': delete_input_value_validator_list,
                'output_validator_list': delete_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'get': {
                'input_type': get_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPSecVpnIkeProfile'),
                'errors': get_error_dict,
                'input_value_validator_list': get_input_value_validator_list,
                'output_validator_list': get_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'list': {
                'input_type': list_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPSecVpnIkeProfileListResult'),
                'errors': list_error_dict,
                'input_value_validator_list': list_input_value_validator_list,
                'output_validator_list': list_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'patch': {
                'input_type': patch_input_type,
                'output_type': type.VoidType(),
                'errors': patch_error_dict,
                'input_value_validator_list': patch_input_value_validator_list,
                'output_validator_list': patch_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'update': {
                'input_type': update_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPSecVpnIkeProfile'),
                'errors': update_error_dict,
                'input_value_validator_list': update_input_value_validator_list,
                'output_validator_list': update_output_validator_list,
                'task_type': TaskType.NONE,
            },
        }
        rest_metadata = {
            'delete': delete_rest_metadata,
            'get': get_rest_metadata,
            'list': list_rest_metadata,
            'patch': patch_rest_metadata,
            'update': update_rest_metadata,
        }
        ApiInterfaceStub.__init__(
            self, iface_name='com.vmware.nsx_policy.infra.ipsec_vpn_ike_profiles',
            config=config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)

class _IpsecVpnTunnelProfilesStub(ApiInterfaceStub):
    def __init__(self, config):
        # properties for delete operation
        delete_input_type = type.StructType('operation-input', {
            'tunnel_profile_id': type.StringType(),
        })
        delete_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        delete_input_value_validator_list = [
        ]
        delete_output_validator_list = [
        ]
        delete_rest_metadata = OperationRestMetadata(
            http_method='DELETE',
            url_template='/policy/api/v1/infra/ipsec-vpn-tunnel-profiles/{tunnel-profile-id}',
            path_variables={
                'tunnel_profile_id': 'tunnel-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for get operation
        get_input_type = type.StructType('operation-input', {
            'tunnel_profile_id': type.StringType(),
        })
        get_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        get_input_value_validator_list = [
        ]
        get_output_validator_list = [
            HasFieldsOfValidator()
        ]
        get_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/ipsec-vpn-tunnel-profiles/{tunnel-profile-id}',
            path_variables={
                'tunnel_profile_id': 'tunnel-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for list operation
        list_input_type = type.StructType('operation-input', {
            'cursor': type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.BooleanType()),
            'included_fields': type.OptionalType(type.StringType()),
            'page_size': type.OptionalType(type.IntegerType()),
            'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType()),
        })
        list_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        list_input_value_validator_list = [
        ]
        list_output_validator_list = [
            HasFieldsOfValidator()
        ]
        list_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/ipsec-vpn-tunnel-profiles',
            path_variables={
            },
            query_parameters={
                'cursor': 'cursor',
                'include_mark_for_delete_objects': 'include_mark_for_delete_objects',
                'included_fields': 'included_fields',
                'page_size': 'page_size',
                'sort_ascending': 'sort_ascending',
                'sort_by': 'sort_by',
            },
            content_type='application/json'
        )

        # properties for patch operation
        patch_input_type = type.StructType('operation-input', {
            'tunnel_profile_id': type.StringType(),
            'ip_sec_vpn_tunnel_profile': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPSecVpnTunnelProfile'),
        })
        patch_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        patch_input_value_validator_list = [
            HasFieldsOfValidator()
        ]
        patch_output_validator_list = [
        ]
        patch_rest_metadata = OperationRestMetadata(
            http_method='PATCH',
            url_template='/policy/api/v1/infra/ipsec-vpn-tunnel-profiles/{tunnel-profile-id}',
            request_body_parameter='ip_sec_vpn_tunnel_profile',
            path_variables={
                'tunnel_profile_id': 'tunnel-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for update operation
        update_input_type = type.StructType('operation-input', {
            'tunnel_profile_id': type.StringType(),
            'ip_sec_vpn_tunnel_profile': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPSecVpnTunnelProfile'),
        })
        update_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        update_input_value_validator_list = [
            HasFieldsOfValidator()
        ]
        update_output_validator_list = [
            HasFieldsOfValidator()
        ]
        update_rest_metadata = OperationRestMetadata(
            http_method='PUT',
            url_template='/policy/api/v1/infra/ipsec-vpn-tunnel-profiles/{tunnel-profile-id}',
            request_body_parameter='ip_sec_vpn_tunnel_profile',
            path_variables={
                'tunnel_profile_id': 'tunnel-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        operations = {
            'delete': {
                'input_type': delete_input_type,
                'output_type': type.VoidType(),
                'errors': delete_error_dict,
                'input_value_validator_list': delete_input_value_validator_list,
                'output_validator_list': delete_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'get': {
                'input_type': get_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPSecVpnTunnelProfile'),
                'errors': get_error_dict,
                'input_value_validator_list': get_input_value_validator_list,
                'output_validator_list': get_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'list': {
                'input_type': list_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPSecVpnTunnelProfileListResult'),
                'errors': list_error_dict,
                'input_value_validator_list': list_input_value_validator_list,
                'output_validator_list': list_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'patch': {
                'input_type': patch_input_type,
                'output_type': type.VoidType(),
                'errors': patch_error_dict,
                'input_value_validator_list': patch_input_value_validator_list,
                'output_validator_list': patch_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'update': {
                'input_type': update_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'IPSecVpnTunnelProfile'),
                'errors': update_error_dict,
                'input_value_validator_list': update_input_value_validator_list,
                'output_validator_list': update_output_validator_list,
                'task_type': TaskType.NONE,
            },
        }
        rest_metadata = {
            'delete': delete_rest_metadata,
            'get': get_rest_metadata,
            'list': list_rest_metadata,
            'patch': patch_rest_metadata,
            'update': update_rest_metadata,
        }
        ApiInterfaceStub.__init__(
            self, iface_name='com.vmware.nsx_policy.infra.ipsec_vpn_tunnel_profiles',
            config=config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)

class _PartnerServicesStub(ApiInterfaceStub):
    def __init__(self, config):
        # properties for get operation
        get_input_type = type.StructType('operation-input', {
            'service_name': type.StringType(),
        })
        get_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        get_input_value_validator_list = [
        ]
        get_output_validator_list = [
        ]
        get_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/partner-services/{service-name}',
            path_variables={
                'service_name': 'service-name',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for list operation
        list_input_type = type.StructType('operation-input', {
            'cursor': type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.BooleanType()),
            'included_fields': type.OptionalType(type.StringType()),
            'page_size': type.OptionalType(type.IntegerType()),
            'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType()),
        })
        list_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        list_input_value_validator_list = [
        ]
        list_output_validator_list = [
        ]
        list_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/partner-services',
            path_variables={
            },
            query_parameters={
                'cursor': 'cursor',
                'include_mark_for_delete_objects': 'include_mark_for_delete_objects',
                'included_fields': 'included_fields',
                'page_size': 'page_size',
                'sort_ascending': 'sort_ascending',
                'sort_by': 'sort_by',
            },
            content_type='application/json'
        )

        operations = {
            'get': {
                'input_type': get_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'ServiceDefinition'),
                'errors': get_error_dict,
                'input_value_validator_list': get_input_value_validator_list,
                'output_validator_list': get_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'list': {
                'input_type': list_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'ServiceInsertionServiceListResult'),
                'errors': list_error_dict,
                'input_value_validator_list': list_input_value_validator_list,
                'output_validator_list': list_output_validator_list,
                'task_type': TaskType.NONE,
            },
        }
        rest_metadata = {
            'get': get_rest_metadata,
            'list': list_rest_metadata,
        }
        ApiInterfaceStub.__init__(
            self, iface_name='com.vmware.nsx_policy.infra.partner_services',
            config=config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)

class _PortMirroringProfilesStub(ApiInterfaceStub):
    def __init__(self, config):
        # properties for delete operation
        delete_input_type = type.StructType('operation-input', {
            'port_mirroring_profile_id': type.StringType(),
        })
        delete_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        delete_input_value_validator_list = [
        ]
        delete_output_validator_list = [
        ]
        delete_rest_metadata = OperationRestMetadata(
            http_method='DELETE',
            url_template='/policy/api/v1/infra/port-mirroring-profiles/{port-mirroring-profile-id}',
            path_variables={
                'port_mirroring_profile_id': 'port-mirroring-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for get operation
        get_input_type = type.StructType('operation-input', {
            'port_mirroring_profile_id': type.StringType(),
        })
        get_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        get_input_value_validator_list = [
        ]
        get_output_validator_list = [
            HasFieldsOfValidator()
        ]
        get_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/port-mirroring-profiles/{port-mirroring-profile-id}',
            path_variables={
                'port_mirroring_profile_id': 'port-mirroring-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for list operation
        list_input_type = type.StructType('operation-input', {
            'cursor': type.OptionalType(type.StringType()),
            'included_fields': type.OptionalType(type.StringType()),
            'page_size': type.OptionalType(type.IntegerType()),
            'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType()),
        })
        list_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        list_input_value_validator_list = [
        ]
        list_output_validator_list = [
            HasFieldsOfValidator()
        ]
        list_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/port-mirroring-profiles',
            path_variables={
            },
            query_parameters={
                'cursor': 'cursor',
                'included_fields': 'included_fields',
                'page_size': 'page_size',
                'sort_ascending': 'sort_ascending',
                'sort_by': 'sort_by',
            },
            content_type='application/json'
        )

        # properties for patch operation
        patch_input_type = type.StructType('operation-input', {
            'port_mirroring_profile_id': type.StringType(),
            'port_mirroring_profile': type.ReferenceType('com.vmware.nsx_policy.model_client', 'PortMirroringProfile'),
        })
        patch_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        patch_input_value_validator_list = [
            HasFieldsOfValidator()
        ]
        patch_output_validator_list = [
        ]
        patch_rest_metadata = OperationRestMetadata(
            http_method='PATCH',
            url_template='/policy/api/v1/infra/port-mirroring-profiles/{port-mirroring-profile-id}',
            request_body_parameter='port_mirroring_profile',
            path_variables={
                'port_mirroring_profile_id': 'port-mirroring-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for update operation
        update_input_type = type.StructType('operation-input', {
            'port_mirroring_profile_id': type.StringType(),
            'port_mirroring_profile': type.ReferenceType('com.vmware.nsx_policy.model_client', 'PortMirroringProfile'),
        })
        update_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        update_input_value_validator_list = [
            HasFieldsOfValidator()
        ]
        update_output_validator_list = [
            HasFieldsOfValidator()
        ]
        update_rest_metadata = OperationRestMetadata(
            http_method='PUT',
            url_template='/policy/api/v1/infra/port-mirroring-profiles/{port-mirroring-profile-id}',
            request_body_parameter='port_mirroring_profile',
            path_variables={
                'port_mirroring_profile_id': 'port-mirroring-profile-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        operations = {
            'delete': {
                'input_type': delete_input_type,
                'output_type': type.VoidType(),
                'errors': delete_error_dict,
                'input_value_validator_list': delete_input_value_validator_list,
                'output_validator_list': delete_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'get': {
                'input_type': get_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'PortMirroringProfile'),
                'errors': get_error_dict,
                'input_value_validator_list': get_input_value_validator_list,
                'output_validator_list': get_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'list': {
                'input_type': list_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'PortMirroringProfileListResult'),
                'errors': list_error_dict,
                'input_value_validator_list': list_input_value_validator_list,
                'output_validator_list': list_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'patch': {
                'input_type': patch_input_type,
                'output_type': type.VoidType(),
                'errors': patch_error_dict,
                'input_value_validator_list': patch_input_value_validator_list,
                'output_validator_list': patch_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'update': {
                'input_type': update_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'PortMirroringProfile'),
                'errors': update_error_dict,
                'input_value_validator_list': update_input_value_validator_list,
                'output_validator_list': update_output_validator_list,
                'task_type': TaskType.NONE,
            },
        }
        rest_metadata = {
            'delete': delete_rest_metadata,
            'get': get_rest_metadata,
            'list': list_rest_metadata,
            'patch': patch_rest_metadata,
            'update': update_rest_metadata,
        }
        ApiInterfaceStub.__init__(
            self, iface_name='com.vmware.nsx_policy.infra.port_mirroring_profiles',
            config=config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)

class _SegmentsStub(ApiInterfaceStub):
    def __init__(self, config):
        # properties for delete operation
        delete_input_type = type.StructType('operation-input', {
            'segment_id': type.StringType(),
        })
        delete_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        delete_input_value_validator_list = [
        ]
        delete_output_validator_list = [
        ]
        delete_rest_metadata = OperationRestMetadata(
            http_method='DELETE',
            url_template='/policy/api/v1/infra/segments/{segment-id}',
            path_variables={
                'segment_id': 'segment-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for delete_0 operation
        delete_0_input_type = type.StructType('operation-input', {
            'segment_id': type.StringType(),
        })
        delete_0_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        delete_0_input_value_validator_list = [
        ]
        delete_0_output_validator_list = [
        ]
        delete_0_rest_metadata = OperationRestMetadata(
            http_method='DELETE',
            url_template='/policy/api/v1/infra/segments/{segment-id}?force=true',
            path_variables={
                'segment_id': 'segment-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for get operation
        get_input_type = type.StructType('operation-input', {
            'segment_id': type.StringType(),
        })
        get_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        get_input_value_validator_list = [
        ]
        get_output_validator_list = [
            HasFieldsOfValidator()
        ]
        get_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/segments/{segment-id}',
            path_variables={
                'segment_id': 'segment-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for list operation
        list_input_type = type.StructType('operation-input', {
            'cursor': type.OptionalType(type.StringType()),
            'include_mark_for_delete_objects': type.OptionalType(type.BooleanType()),
            'included_fields': type.OptionalType(type.StringType()),
            'page_size': type.OptionalType(type.IntegerType()),
            'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType()),
        })
        list_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        list_input_value_validator_list = [
        ]
        list_output_validator_list = [
            HasFieldsOfValidator()
        ]
        list_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/segments',
            path_variables={
            },
            query_parameters={
                'cursor': 'cursor',
                'include_mark_for_delete_objects': 'include_mark_for_delete_objects',
                'included_fields': 'included_fields',
                'page_size': 'page_size',
                'sort_ascending': 'sort_ascending',
                'sort_by': 'sort_by',
            },
            content_type='application/json'
        )

        # properties for patch operation
        patch_input_type = type.StructType('operation-input', {
            'segment_id': type.StringType(),
            'segment': type.ReferenceType('com.vmware.nsx_policy.model_client', 'Segment'),
        })
        patch_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        patch_input_value_validator_list = [
            HasFieldsOfValidator()
        ]
        patch_output_validator_list = [
        ]
        patch_rest_metadata = OperationRestMetadata(
            http_method='PATCH',
            url_template='/policy/api/v1/infra/segments/{segment-id}',
            request_body_parameter='segment',
            path_variables={
                'segment_id': 'segment-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for update operation
        update_input_type = type.StructType('operation-input', {
            'segment_id': type.StringType(),
            'segment': type.ReferenceType('com.vmware.nsx_policy.model_client', 'Segment'),
        })
        update_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        update_input_value_validator_list = [
            HasFieldsOfValidator()
        ]
        update_output_validator_list = [
            HasFieldsOfValidator()
        ]
        update_rest_metadata = OperationRestMetadata(
            http_method='PUT',
            url_template='/policy/api/v1/infra/segments/{segment-id}',
            request_body_parameter='segment',
            path_variables={
                'segment_id': 'segment-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        operations = {
            'delete': {
                'input_type': delete_input_type,
                'output_type': type.VoidType(),
                'errors': delete_error_dict,
                'input_value_validator_list': delete_input_value_validator_list,
                'output_validator_list': delete_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'delete_0': {
                'input_type': delete_0_input_type,
                'output_type': type.VoidType(),
                'errors': delete_0_error_dict,
                'input_value_validator_list': delete_0_input_value_validator_list,
                'output_validator_list': delete_0_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'get': {
                'input_type': get_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'Segment'),
                'errors': get_error_dict,
                'input_value_validator_list': get_input_value_validator_list,
                'output_validator_list': get_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'list': {
                'input_type': list_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'SegmentListResult'),
                'errors': list_error_dict,
                'input_value_validator_list': list_input_value_validator_list,
                'output_validator_list': list_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'patch': {
                'input_type': patch_input_type,
                'output_type': type.VoidType(),
                'errors': patch_error_dict,
                'input_value_validator_list': patch_input_value_validator_list,
                'output_validator_list': patch_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'update': {
                'input_type': update_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'Segment'),
                'errors': update_error_dict,
                'input_value_validator_list': update_input_value_validator_list,
                'output_validator_list': update_output_validator_list,
                'task_type': TaskType.NONE,
            },
        }
        rest_metadata = {
            'delete': delete_rest_metadata,
            'delete_0': delete_0_rest_metadata,
            'get': get_rest_metadata,
            'list': list_rest_metadata,
            'patch': patch_rest_metadata,
            'update': update_rest_metadata,
        }
        ApiInterfaceStub.__init__(
            self, iface_name='com.vmware.nsx_policy.infra.segments',
            config=config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)

class _ServicesStub(ApiInterfaceStub):
    def __init__(self, config):
        # properties for delete operation
        delete_input_type = type.StructType('operation-input', {
            'service_id': type.StringType(),
        })
        delete_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        delete_input_value_validator_list = [
        ]
        delete_output_validator_list = [
        ]
        delete_rest_metadata = OperationRestMetadata(
            http_method='DELETE',
            url_template='/policy/api/v1/infra/services/{service-id}',
            path_variables={
                'service_id': 'service-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for get operation
        get_input_type = type.StructType('operation-input', {
            'service_id': type.StringType(),
        })
        get_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        get_input_value_validator_list = [
        ]
        get_output_validator_list = [
            HasFieldsOfValidator()
        ]
        get_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/services/{service-id}',
            path_variables={
                'service_id': 'service-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for list operation
        list_input_type = type.StructType('operation-input', {
            'cursor': type.OptionalType(type.StringType()),
            'default_service': type.OptionalType(type.BooleanType()),
            'include_mark_for_delete_objects': type.OptionalType(type.BooleanType()),
            'included_fields': type.OptionalType(type.StringType()),
            'page_size': type.OptionalType(type.IntegerType()),
            'sort_ascending': type.OptionalType(type.BooleanType()),
            'sort_by': type.OptionalType(type.StringType()),
        })
        list_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        list_input_value_validator_list = [
        ]
        list_output_validator_list = [
            HasFieldsOfValidator()
        ]
        list_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/infra/services',
            path_variables={
            },
            query_parameters={
                'cursor': 'cursor',
                'default_service': 'default_service',
                'include_mark_for_delete_objects': 'include_mark_for_delete_objects',
                'included_fields': 'included_fields',
                'page_size': 'page_size',
                'sort_ascending': 'sort_ascending',
                'sort_by': 'sort_by',
            },
            content_type='application/json'
        )

        # properties for patch operation
        patch_input_type = type.StructType('operation-input', {
            'service_id': type.StringType(),
            'service': type.ReferenceType('com.vmware.nsx_policy.model_client', 'Service'),
        })
        patch_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        patch_input_value_validator_list = [
            HasFieldsOfValidator()
        ]
        patch_output_validator_list = [
        ]
        patch_rest_metadata = OperationRestMetadata(
            http_method='PATCH',
            url_template='/policy/api/v1/infra/services/{service-id}',
            request_body_parameter='service',
            path_variables={
                'service_id': 'service-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        # properties for update operation
        update_input_type = type.StructType('operation-input', {
            'service_id': type.StringType(),
            'service': type.ReferenceType('com.vmware.nsx_policy.model_client', 'Service'),
        })
        update_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
                type.ReferenceType('com.vmware.vapi.std.errors_client', 'NotFound'),

        }
        update_input_value_validator_list = [
            HasFieldsOfValidator()
        ]
        update_output_validator_list = [
            HasFieldsOfValidator()
        ]
        update_rest_metadata = OperationRestMetadata(
            http_method='PUT',
            url_template='/policy/api/v1/infra/services/{service-id}',
            request_body_parameter='service',
            path_variables={
                'service_id': 'service-id',
            },
            query_parameters={
            },
            content_type='application/json'
        )

        operations = {
            'delete': {
                'input_type': delete_input_type,
                'output_type': type.VoidType(),
                'errors': delete_error_dict,
                'input_value_validator_list': delete_input_value_validator_list,
                'output_validator_list': delete_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'get': {
                'input_type': get_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'Service'),
                'errors': get_error_dict,
                'input_value_validator_list': get_input_value_validator_list,
                'output_validator_list': get_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'list': {
                'input_type': list_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'ServiceListResult'),
                'errors': list_error_dict,
                'input_value_validator_list': list_input_value_validator_list,
                'output_validator_list': list_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'patch': {
                'input_type': patch_input_type,
                'output_type': type.VoidType(),
                'errors': patch_error_dict,
                'input_value_validator_list': patch_input_value_validator_list,
                'output_validator_list': patch_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'update': {
                'input_type': update_input_type,
                'output_type': type.ReferenceType('com.vmware.nsx_policy.model_client', 'Service'),
                'errors': update_error_dict,
                'input_value_validator_list': update_input_value_validator_list,
                'output_validator_list': update_output_validator_list,
                'task_type': TaskType.NONE,
            },
        }
        rest_metadata = {
            'delete': delete_rest_metadata,
            'get': get_rest_metadata,
            'list': list_rest_metadata,
            'patch': patch_rest_metadata,
            'update': update_rest_metadata,
        }
        ApiInterfaceStub.__init__(
            self, iface_name='com.vmware.nsx_policy.infra.services',
            config=config, operations=operations, rest_metadata=rest_metadata,
            is_vapi_rest=False)


class StubFactory(StubFactoryBase):
    _attrs = {
        'DhcpRelayConfigs': DhcpRelayConfigs,
        'DhcpServerConfigs': DhcpServerConfigs,
        'DnsForwarderZones': DnsForwarderZones,
        'Domains': Domains,
        'Drafts': Drafts,
        'GroupAssociations': GroupAssociations,
        'IpfixCollectorProfiles': IpfixCollectorProfiles,
        'IpfixDfwCollectorProfiles': IpfixDfwCollectorProfiles,
        'IpfixDfwProfiles': IpfixDfwProfiles,
        'IpfixL2CollectorProfiles': IpfixL2CollectorProfiles,
        'IpfixL2Profiles': IpfixL2Profiles,
        'IpsecVpnDpdProfiles': IpsecVpnDpdProfiles,
        'IpsecVpnIkeProfiles': IpsecVpnIkeProfiles,
        'IpsecVpnTunnelProfiles': IpsecVpnTunnelProfiles,
        'PartnerServices': PartnerServices,
        'PortMirroringProfiles': PortMirroringProfiles,
        'Segments': Segments,
        'Services': Services,
        'domains': 'com.vmware.nsx_policy.infra.domains_client.StubFactory',
        'drafts': 'com.vmware.nsx_policy.infra.drafts_client.StubFactory',
        'realized_state': 'com.vmware.nsx_policy.infra.realized_state_client.StubFactory',
        'segments': 'com.vmware.nsx_policy.infra.segments_client.StubFactory',
        'services': 'com.vmware.nsx_policy.infra.services_client.StubFactory',
        'sites': 'com.vmware.nsx_policy.infra.sites_client.StubFactory',
        'tier_0s': 'com.vmware.nsx_policy.infra.tier_0s_client.StubFactory',
        'tier_1s': 'com.vmware.nsx_policy.infra.tier_1s_client.StubFactory',
    }

