diff --git a/.azure-pipelines/client.yml b/.azure-pipelines/client.yml
index 3a8ead1d5c75..983666598c61 100644
--- a/.azure-pipelines/client.yml
+++ b/.azure-pipelines/client.yml
@@ -48,6 +48,13 @@ jobs:
vmImage: 'ubuntu-16.04'
steps:
+ # sudo is required for pip install, as a console_entrypoint shim needs to be placed in bin
+ - script: |
+ pip install setuptools wheel
+ sudo pip install doc-warden
+ ward scan -d $(Build.SourcesDirectory)
+ displayName: 'Verify Readmes'
+
- task: UsePythonVersion@0
displayName: 'Use Python $(PythonVersion)'
inputs:
diff --git a/.docsettings.yml b/.docsettings.yml
new file mode 100644
index 000000000000..a1fa168c1077
--- /dev/null
+++ b/.docsettings.yml
@@ -0,0 +1,6 @@
+omitted_paths:
+ - azure-sdk-tools/*
+ - scripts/*
+ - azure-mgmt-netapp/tests/*
+language: python
+root_check_enabled: True
diff --git a/README.rst b/README.rst
index 94a01f58bc8c..8697be6e7978 100644
--- a/README.rst
+++ b/README.rst
@@ -7,18 +7,15 @@ Microsoft Azure SDK for Python
.. image:: https://img.shields.io/pypi/pyversions/azure.svg?maxAge=2592000
:target: https://pypi.python.org/pypi/azure/
+.. image:: https://dev.azure.com/azure-sdk/public/_apis/build/status/46?branchName=master
+ :target: https://dev.azure.com/azure-sdk/public/_build/latest?definitionId=46&branchName=master
+
.. image:: https://travis-ci.org/Azure/azure-sdk-for-python.svg?branch=master
:target: https://travis-ci.org/Azure/azure-sdk-for-python
-.. image:: https://ci.appveyor.com/api/projects/status/m51hrgewcxknxhsd/branch/master?svg=true
- :target: https://ci.appveyor.com/project/lmazuel/azure-sdk-for-python/branch/master
-
.. image:: https://img.shields.io/badge/dependencies-analyzed-blue.svg
:target: https://azuresdkartifacts.blob.core.windows.net/azure-sdk-for-python/dependencies/dependencies.html
-.. image:: https://dev.azure.com/azure-sdk/public/_apis/build/status/46?branchName=master
- :target: https://dev.azure.com/azure-sdk/public/_build/latest?definitionId=46&branchName=master
-
This project provides a set of Python packages that make it easy to
access Management (Virtual Machines, ...) or Runtime (ServiceBus using HTTP, Batch, Monitor) components of
`Microsoft Azure `_
diff --git a/azure-mgmt-network/HISTORY.rst b/azure-mgmt-network/HISTORY.rst
index 14b850fadf1a..5e3bdcdc00c1 100644
--- a/azure-mgmt-network/HISTORY.rst
+++ b/azure-mgmt-network/HISTORY.rst
@@ -3,6 +3,17 @@
Release History
===============
+2.6.0rc1 (2019-02-15)
++++++++++++++++++++++
+
+**Features**
+
+- Model AzureFirewall has a new parameter threat_intel_mode
+- Model ApplicationGatewayRewriteRule has a new parameter conditions
+- Model ApplicationGatewayRewriteRule has a new parameter rule_sequence
+- Model ApplicationGatewayAutoscaleConfiguration has a new parameter max_capacity
+- Added operation SubnetsOperations.prepare_network_policies
+
2.5.1 (2019-01-15)
++++++++++++++++++
diff --git a/azure-mgmt-network/README.rst b/azure-mgmt-network/README.rst
index 316d56c6614f..eb3792760583 100644
--- a/azure-mgmt-network/README.rst
+++ b/azure-mgmt-network/README.rst
@@ -14,25 +14,6 @@ For the older Azure Service Management (ASM) libraries, see
For a more complete set of Azure libraries, see the `azure `__ bundle package.
-Compatibility
-=============
-
-**IMPORTANT**: If you have an earlier version of the azure package
-(version < 1.0), you should uninstall it before installing this package.
-
-You can check the version using pip:
-
-.. code:: shell
-
- pip freeze
-
-If you see azure==0.11.0 (or any version below 1.0), uninstall it first:
-
-.. code:: shell
-
- pip uninstall azure
-
-
Usage
=====
diff --git a/azure-mgmt-network/azure/mgmt/network/network_management_client.py b/azure-mgmt-network/azure/mgmt/network/network_management_client.py
index e08932534ecc..5b744456bf90 100644
--- a/azure-mgmt-network/azure/mgmt/network/network_management_client.py
+++ b/azure-mgmt-network/azure/mgmt/network/network_management_client.py
@@ -123,7 +123,9 @@ def check_dns_name_availability(
:raises: :class:`CloudError`
"""
api_version = self._get_api_version('check_dns_name_availability')
- if api_version == '2018-11-01':
+ if api_version == '2018-12-01':
+ from .v2018_12_01 import NetworkManagementClient as ClientClass
+ elif api_version == '2018-11-01':
from .v2018_11_01 import NetworkManagementClient as ClientClass
elif api_version == '2018-10-01':
from .v2018_10_01 import NetworkManagementClient as ClientClass
@@ -193,6 +195,7 @@ def models(cls, api_version=DEFAULT_API_VERSION):
* 2018-08-01: :mod:`v2018_08_01.models`
* 2018-10-01: :mod:`v2018_10_01.models`
* 2018-11-01: :mod:`v2018_11_01.models`
+ * 2018-12-01: :mod:`v2018_12_01.models`
"""
if api_version == '2015-06-15':
from .v2015_06_15 import models
@@ -245,6 +248,9 @@ def models(cls, api_version=DEFAULT_API_VERSION):
elif api_version == '2018-11-01':
from .v2018_11_01 import models
return models
+ elif api_version == '2018-12-01':
+ from .v2018_12_01 import models
+ return models
raise NotImplementedError("APIVersion {} is not available".format(api_version))
@property
@@ -268,6 +274,7 @@ def application_gateways(self):
* 2018-08-01: :class:`ApplicationGatewaysOperations`
* 2018-10-01: :class:`ApplicationGatewaysOperations`
* 2018-11-01: :class:`ApplicationGatewaysOperations`
+ * 2018-12-01: :class:`ApplicationGatewaysOperations`
"""
api_version = self._get_api_version('application_gateways')
if api_version == '2015-06-15':
@@ -304,6 +311,8 @@ def application_gateways(self):
from .v2018_10_01.operations import ApplicationGatewaysOperations as OperationClass
elif api_version == '2018-11-01':
from .v2018_11_01.operations import ApplicationGatewaysOperations as OperationClass
+ elif api_version == '2018-12-01':
+ from .v2018_12_01.operations import ApplicationGatewaysOperations as OperationClass
else:
raise NotImplementedError("APIVersion {} is not available".format(api_version))
return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -323,6 +332,7 @@ def application_security_groups(self):
* 2018-08-01: :class:`ApplicationSecurityGroupsOperations`
* 2018-10-01: :class:`ApplicationSecurityGroupsOperations`
* 2018-11-01: :class:`ApplicationSecurityGroupsOperations`
+ * 2018-12-01: :class:`ApplicationSecurityGroupsOperations`
"""
api_version = self._get_api_version('application_security_groups')
if api_version == '2017-09-01':
@@ -347,6 +357,8 @@ def application_security_groups(self):
from .v2018_10_01.operations import ApplicationSecurityGroupsOperations as OperationClass
elif api_version == '2018-11-01':
from .v2018_11_01.operations import ApplicationSecurityGroupsOperations as OperationClass
+ elif api_version == '2018-12-01':
+ from .v2018_12_01.operations import ApplicationSecurityGroupsOperations as OperationClass
else:
raise NotImplementedError("APIVersion {} is not available".format(api_version))
return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -358,6 +370,7 @@ def available_delegations(self):
* 2018-08-01: :class:`AvailableDelegationsOperations`
* 2018-10-01: :class:`AvailableDelegationsOperations`
* 2018-11-01: :class:`AvailableDelegationsOperations`
+ * 2018-12-01: :class:`AvailableDelegationsOperations`
"""
api_version = self._get_api_version('available_delegations')
if api_version == '2018-08-01':
@@ -366,6 +379,8 @@ def available_delegations(self):
from .v2018_10_01.operations import AvailableDelegationsOperations as OperationClass
elif api_version == '2018-11-01':
from .v2018_11_01.operations import AvailableDelegationsOperations as OperationClass
+ elif api_version == '2018-12-01':
+ from .v2018_12_01.operations import AvailableDelegationsOperations as OperationClass
else:
raise NotImplementedError("APIVersion {} is not available".format(api_version))
return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -387,6 +402,7 @@ def available_endpoint_services(self):
* 2018-08-01: :class:`AvailableEndpointServicesOperations`
* 2018-10-01: :class:`AvailableEndpointServicesOperations`
* 2018-11-01: :class:`AvailableEndpointServicesOperations`
+ * 2018-12-01: :class:`AvailableEndpointServicesOperations`
"""
api_version = self._get_api_version('available_endpoint_services')
if api_version == '2017-06-01':
@@ -415,6 +431,8 @@ def available_endpoint_services(self):
from .v2018_10_01.operations import AvailableEndpointServicesOperations as OperationClass
elif api_version == '2018-11-01':
from .v2018_11_01.operations import AvailableEndpointServicesOperations as OperationClass
+ elif api_version == '2018-12-01':
+ from .v2018_12_01.operations import AvailableEndpointServicesOperations as OperationClass
else:
raise NotImplementedError("APIVersion {} is not available".format(api_version))
return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -426,6 +444,7 @@ def available_resource_group_delegations(self):
* 2018-08-01: :class:`AvailableResourceGroupDelegationsOperations`
* 2018-10-01: :class:`AvailableResourceGroupDelegationsOperations`
* 2018-11-01: :class:`AvailableResourceGroupDelegationsOperations`
+ * 2018-12-01: :class:`AvailableResourceGroupDelegationsOperations`
"""
api_version = self._get_api_version('available_resource_group_delegations')
if api_version == '2018-08-01':
@@ -434,6 +453,8 @@ def available_resource_group_delegations(self):
from .v2018_10_01.operations import AvailableResourceGroupDelegationsOperations as OperationClass
elif api_version == '2018-11-01':
from .v2018_11_01.operations import AvailableResourceGroupDelegationsOperations as OperationClass
+ elif api_version == '2018-12-01':
+ from .v2018_12_01.operations import AvailableResourceGroupDelegationsOperations as OperationClass
else:
raise NotImplementedError("APIVersion {} is not available".format(api_version))
return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -445,6 +466,7 @@ def azure_firewall_fqdn_tags(self):
* 2018-08-01: :class:`AzureFirewallFqdnTagsOperations`
* 2018-10-01: :class:`AzureFirewallFqdnTagsOperations`
* 2018-11-01: :class:`AzureFirewallFqdnTagsOperations`
+ * 2018-12-01: :class:`AzureFirewallFqdnTagsOperations`
"""
api_version = self._get_api_version('azure_firewall_fqdn_tags')
if api_version == '2018-08-01':
@@ -453,6 +475,8 @@ def azure_firewall_fqdn_tags(self):
from .v2018_10_01.operations import AzureFirewallFqdnTagsOperations as OperationClass
elif api_version == '2018-11-01':
from .v2018_11_01.operations import AzureFirewallFqdnTagsOperations as OperationClass
+ elif api_version == '2018-12-01':
+ from .v2018_12_01.operations import AzureFirewallFqdnTagsOperations as OperationClass
else:
raise NotImplementedError("APIVersion {} is not available".format(api_version))
return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -467,6 +491,7 @@ def azure_firewalls(self):
* 2018-08-01: :class:`AzureFirewallsOperations`
* 2018-10-01: :class:`AzureFirewallsOperations`
* 2018-11-01: :class:`AzureFirewallsOperations`
+ * 2018-12-01: :class:`AzureFirewallsOperations`
"""
api_version = self._get_api_version('azure_firewalls')
if api_version == '2018-04-01':
@@ -481,6 +506,8 @@ def azure_firewalls(self):
from .v2018_10_01.operations import AzureFirewallsOperations as OperationClass
elif api_version == '2018-11-01':
from .v2018_11_01.operations import AzureFirewallsOperations as OperationClass
+ elif api_version == '2018-12-01':
+ from .v2018_12_01.operations import AzureFirewallsOperations as OperationClass
else:
raise NotImplementedError("APIVersion {} is not available".format(api_version))
return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -504,6 +531,7 @@ def bgp_service_communities(self):
* 2018-08-01: :class:`BgpServiceCommunitiesOperations`
* 2018-10-01: :class:`BgpServiceCommunitiesOperations`
* 2018-11-01: :class:`BgpServiceCommunitiesOperations`
+ * 2018-12-01: :class:`BgpServiceCommunitiesOperations`
"""
api_version = self._get_api_version('bgp_service_communities')
if api_version == '2016-12-01':
@@ -536,6 +564,8 @@ def bgp_service_communities(self):
from .v2018_10_01.operations import BgpServiceCommunitiesOperations as OperationClass
elif api_version == '2018-11-01':
from .v2018_11_01.operations import BgpServiceCommunitiesOperations as OperationClass
+ elif api_version == '2018-12-01':
+ from .v2018_12_01.operations import BgpServiceCommunitiesOperations as OperationClass
else:
raise NotImplementedError("APIVersion {} is not available".format(api_version))
return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -554,6 +584,7 @@ def connection_monitors(self):
* 2018-08-01: :class:`ConnectionMonitorsOperations`
* 2018-10-01: :class:`ConnectionMonitorsOperations`
* 2018-11-01: :class:`ConnectionMonitorsOperations`
+ * 2018-12-01: :class:`ConnectionMonitorsOperations`
"""
api_version = self._get_api_version('connection_monitors')
if api_version == '2017-10-01':
@@ -576,6 +607,8 @@ def connection_monitors(self):
from .v2018_10_01.operations import ConnectionMonitorsOperations as OperationClass
elif api_version == '2018-11-01':
from .v2018_11_01.operations import ConnectionMonitorsOperations as OperationClass
+ elif api_version == '2018-12-01':
+ from .v2018_12_01.operations import ConnectionMonitorsOperations as OperationClass
else:
raise NotImplementedError("APIVersion {} is not available".format(api_version))
return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -585,10 +618,13 @@ def ddos_custom_policies(self):
"""Instance depends on the API version:
* 2018-11-01: :class:`DdosCustomPoliciesOperations`
+ * 2018-12-01: :class:`DdosCustomPoliciesOperations`
"""
api_version = self._get_api_version('ddos_custom_policies')
if api_version == '2018-11-01':
from .v2018_11_01.operations import DdosCustomPoliciesOperations as OperationClass
+ elif api_version == '2018-12-01':
+ from .v2018_12_01.operations import DdosCustomPoliciesOperations as OperationClass
else:
raise NotImplementedError("APIVersion {} is not available".format(api_version))
return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -604,6 +640,7 @@ def ddos_protection_plans(self):
* 2018-08-01: :class:`DdosProtectionPlansOperations`
* 2018-10-01: :class:`DdosProtectionPlansOperations`
* 2018-11-01: :class:`DdosProtectionPlansOperations`
+ * 2018-12-01: :class:`DdosProtectionPlansOperations`
"""
api_version = self._get_api_version('ddos_protection_plans')
if api_version == '2018-02-01':
@@ -620,6 +657,8 @@ def ddos_protection_plans(self):
from .v2018_10_01.operations import DdosProtectionPlansOperations as OperationClass
elif api_version == '2018-11-01':
from .v2018_11_01.operations import DdosProtectionPlansOperations as OperationClass
+ elif api_version == '2018-12-01':
+ from .v2018_12_01.operations import DdosProtectionPlansOperations as OperationClass
else:
raise NotImplementedError("APIVersion {} is not available".format(api_version))
return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -641,6 +680,7 @@ def default_security_rules(self):
* 2018-08-01: :class:`DefaultSecurityRulesOperations`
* 2018-10-01: :class:`DefaultSecurityRulesOperations`
* 2018-11-01: :class:`DefaultSecurityRulesOperations`
+ * 2018-12-01: :class:`DefaultSecurityRulesOperations`
"""
api_version = self._get_api_version('default_security_rules')
if api_version == '2017-06-01':
@@ -669,6 +709,8 @@ def default_security_rules(self):
from .v2018_10_01.operations import DefaultSecurityRulesOperations as OperationClass
elif api_version == '2018-11-01':
from .v2018_11_01.operations import DefaultSecurityRulesOperations as OperationClass
+ elif api_version == '2018-12-01':
+ from .v2018_12_01.operations import DefaultSecurityRulesOperations as OperationClass
else:
raise NotImplementedError("APIVersion {} is not available".format(api_version))
return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -694,6 +736,7 @@ def express_route_circuit_authorizations(self):
* 2018-08-01: :class:`ExpressRouteCircuitAuthorizationsOperations`
* 2018-10-01: :class:`ExpressRouteCircuitAuthorizationsOperations`
* 2018-11-01: :class:`ExpressRouteCircuitAuthorizationsOperations`
+ * 2018-12-01: :class:`ExpressRouteCircuitAuthorizationsOperations`
"""
api_version = self._get_api_version('express_route_circuit_authorizations')
if api_version == '2015-06-15':
@@ -730,6 +773,8 @@ def express_route_circuit_authorizations(self):
from .v2018_10_01.operations import ExpressRouteCircuitAuthorizationsOperations as OperationClass
elif api_version == '2018-11-01':
from .v2018_11_01.operations import ExpressRouteCircuitAuthorizationsOperations as OperationClass
+ elif api_version == '2018-12-01':
+ from .v2018_12_01.operations import ExpressRouteCircuitAuthorizationsOperations as OperationClass
else:
raise NotImplementedError("APIVersion {} is not available".format(api_version))
return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -745,6 +790,7 @@ def express_route_circuit_connections(self):
* 2018-08-01: :class:`ExpressRouteCircuitConnectionsOperations`
* 2018-10-01: :class:`ExpressRouteCircuitConnectionsOperations`
* 2018-11-01: :class:`ExpressRouteCircuitConnectionsOperations`
+ * 2018-12-01: :class:`ExpressRouteCircuitConnectionsOperations`
"""
api_version = self._get_api_version('express_route_circuit_connections')
if api_version == '2018-02-01':
@@ -761,6 +807,8 @@ def express_route_circuit_connections(self):
from .v2018_10_01.operations import ExpressRouteCircuitConnectionsOperations as OperationClass
elif api_version == '2018-11-01':
from .v2018_11_01.operations import ExpressRouteCircuitConnectionsOperations as OperationClass
+ elif api_version == '2018-12-01':
+ from .v2018_12_01.operations import ExpressRouteCircuitConnectionsOperations as OperationClass
else:
raise NotImplementedError("APIVersion {} is not available".format(api_version))
return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -786,6 +834,7 @@ def express_route_circuit_peerings(self):
* 2018-08-01: :class:`ExpressRouteCircuitPeeringsOperations`
* 2018-10-01: :class:`ExpressRouteCircuitPeeringsOperations`
* 2018-11-01: :class:`ExpressRouteCircuitPeeringsOperations`
+ * 2018-12-01: :class:`ExpressRouteCircuitPeeringsOperations`
"""
api_version = self._get_api_version('express_route_circuit_peerings')
if api_version == '2015-06-15':
@@ -822,6 +871,8 @@ def express_route_circuit_peerings(self):
from .v2018_10_01.operations import ExpressRouteCircuitPeeringsOperations as OperationClass
elif api_version == '2018-11-01':
from .v2018_11_01.operations import ExpressRouteCircuitPeeringsOperations as OperationClass
+ elif api_version == '2018-12-01':
+ from .v2018_12_01.operations import ExpressRouteCircuitPeeringsOperations as OperationClass
else:
raise NotImplementedError("APIVersion {} is not available".format(api_version))
return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -847,6 +898,7 @@ def express_route_circuits(self):
* 2018-08-01: :class:`ExpressRouteCircuitsOperations`
* 2018-10-01: :class:`ExpressRouteCircuitsOperations`
* 2018-11-01: :class:`ExpressRouteCircuitsOperations`
+ * 2018-12-01: :class:`ExpressRouteCircuitsOperations`
"""
api_version = self._get_api_version('express_route_circuits')
if api_version == '2015-06-15':
@@ -883,6 +935,8 @@ def express_route_circuits(self):
from .v2018_10_01.operations import ExpressRouteCircuitsOperations as OperationClass
elif api_version == '2018-11-01':
from .v2018_11_01.operations import ExpressRouteCircuitsOperations as OperationClass
+ elif api_version == '2018-12-01':
+ from .v2018_12_01.operations import ExpressRouteCircuitsOperations as OperationClass
else:
raise NotImplementedError("APIVersion {} is not available".format(api_version))
return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -894,6 +948,7 @@ def express_route_connections(self):
* 2018-08-01: :class:`ExpressRouteConnectionsOperations`
* 2018-10-01: :class:`ExpressRouteConnectionsOperations`
* 2018-11-01: :class:`ExpressRouteConnectionsOperations`
+ * 2018-12-01: :class:`ExpressRouteConnectionsOperations`
"""
api_version = self._get_api_version('express_route_connections')
if api_version == '2018-08-01':
@@ -902,6 +957,8 @@ def express_route_connections(self):
from .v2018_10_01.operations import ExpressRouteConnectionsOperations as OperationClass
elif api_version == '2018-11-01':
from .v2018_11_01.operations import ExpressRouteConnectionsOperations as OperationClass
+ elif api_version == '2018-12-01':
+ from .v2018_12_01.operations import ExpressRouteConnectionsOperations as OperationClass
else:
raise NotImplementedError("APIVersion {} is not available".format(api_version))
return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -917,6 +974,7 @@ def express_route_cross_connection_peerings(self):
* 2018-08-01: :class:`ExpressRouteCrossConnectionPeeringsOperations`
* 2018-10-01: :class:`ExpressRouteCrossConnectionPeeringsOperations`
* 2018-11-01: :class:`ExpressRouteCrossConnectionPeeringsOperations`
+ * 2018-12-01: :class:`ExpressRouteCrossConnectionPeeringsOperations`
"""
api_version = self._get_api_version('express_route_cross_connection_peerings')
if api_version == '2018-02-01':
@@ -933,6 +991,8 @@ def express_route_cross_connection_peerings(self):
from .v2018_10_01.operations import ExpressRouteCrossConnectionPeeringsOperations as OperationClass
elif api_version == '2018-11-01':
from .v2018_11_01.operations import ExpressRouteCrossConnectionPeeringsOperations as OperationClass
+ elif api_version == '2018-12-01':
+ from .v2018_12_01.operations import ExpressRouteCrossConnectionPeeringsOperations as OperationClass
else:
raise NotImplementedError("APIVersion {} is not available".format(api_version))
return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -948,6 +1008,7 @@ def express_route_cross_connections(self):
* 2018-08-01: :class:`ExpressRouteCrossConnectionsOperations`
* 2018-10-01: :class:`ExpressRouteCrossConnectionsOperations`
* 2018-11-01: :class:`ExpressRouteCrossConnectionsOperations`
+ * 2018-12-01: :class:`ExpressRouteCrossConnectionsOperations`
"""
api_version = self._get_api_version('express_route_cross_connections')
if api_version == '2018-02-01':
@@ -964,6 +1025,8 @@ def express_route_cross_connections(self):
from .v2018_10_01.operations import ExpressRouteCrossConnectionsOperations as OperationClass
elif api_version == '2018-11-01':
from .v2018_11_01.operations import ExpressRouteCrossConnectionsOperations as OperationClass
+ elif api_version == '2018-12-01':
+ from .v2018_12_01.operations import ExpressRouteCrossConnectionsOperations as OperationClass
else:
raise NotImplementedError("APIVersion {} is not available".format(api_version))
return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -975,6 +1038,7 @@ def express_route_gateways(self):
* 2018-08-01: :class:`ExpressRouteGatewaysOperations`
* 2018-10-01: :class:`ExpressRouteGatewaysOperations`
* 2018-11-01: :class:`ExpressRouteGatewaysOperations`
+ * 2018-12-01: :class:`ExpressRouteGatewaysOperations`
"""
api_version = self._get_api_version('express_route_gateways')
if api_version == '2018-08-01':
@@ -983,6 +1047,8 @@ def express_route_gateways(self):
from .v2018_10_01.operations import ExpressRouteGatewaysOperations as OperationClass
elif api_version == '2018-11-01':
from .v2018_11_01.operations import ExpressRouteGatewaysOperations as OperationClass
+ elif api_version == '2018-12-01':
+ from .v2018_12_01.operations import ExpressRouteGatewaysOperations as OperationClass
else:
raise NotImplementedError("APIVersion {} is not available".format(api_version))
return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -994,6 +1060,7 @@ def express_route_links(self):
* 2018-08-01: :class:`ExpressRouteLinksOperations`
* 2018-10-01: :class:`ExpressRouteLinksOperations`
* 2018-11-01: :class:`ExpressRouteLinksOperations`
+ * 2018-12-01: :class:`ExpressRouteLinksOperations`
"""
api_version = self._get_api_version('express_route_links')
if api_version == '2018-08-01':
@@ -1002,6 +1069,8 @@ def express_route_links(self):
from .v2018_10_01.operations import ExpressRouteLinksOperations as OperationClass
elif api_version == '2018-11-01':
from .v2018_11_01.operations import ExpressRouteLinksOperations as OperationClass
+ elif api_version == '2018-12-01':
+ from .v2018_12_01.operations import ExpressRouteLinksOperations as OperationClass
else:
raise NotImplementedError("APIVersion {} is not available".format(api_version))
return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -1013,6 +1082,7 @@ def express_route_ports(self):
* 2018-08-01: :class:`ExpressRoutePortsOperations`
* 2018-10-01: :class:`ExpressRoutePortsOperations`
* 2018-11-01: :class:`ExpressRoutePortsOperations`
+ * 2018-12-01: :class:`ExpressRoutePortsOperations`
"""
api_version = self._get_api_version('express_route_ports')
if api_version == '2018-08-01':
@@ -1021,6 +1091,8 @@ def express_route_ports(self):
from .v2018_10_01.operations import ExpressRoutePortsOperations as OperationClass
elif api_version == '2018-11-01':
from .v2018_11_01.operations import ExpressRoutePortsOperations as OperationClass
+ elif api_version == '2018-12-01':
+ from .v2018_12_01.operations import ExpressRoutePortsOperations as OperationClass
else:
raise NotImplementedError("APIVersion {} is not available".format(api_version))
return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -1032,6 +1104,7 @@ def express_route_ports_locations(self):
* 2018-08-01: :class:`ExpressRoutePortsLocationsOperations`
* 2018-10-01: :class:`ExpressRoutePortsLocationsOperations`
* 2018-11-01: :class:`ExpressRoutePortsLocationsOperations`
+ * 2018-12-01: :class:`ExpressRoutePortsLocationsOperations`
"""
api_version = self._get_api_version('express_route_ports_locations')
if api_version == '2018-08-01':
@@ -1040,6 +1113,8 @@ def express_route_ports_locations(self):
from .v2018_10_01.operations import ExpressRoutePortsLocationsOperations as OperationClass
elif api_version == '2018-11-01':
from .v2018_11_01.operations import ExpressRoutePortsLocationsOperations as OperationClass
+ elif api_version == '2018-12-01':
+ from .v2018_12_01.operations import ExpressRoutePortsLocationsOperations as OperationClass
else:
raise NotImplementedError("APIVersion {} is not available".format(api_version))
return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -1065,6 +1140,7 @@ def express_route_service_providers(self):
* 2018-08-01: :class:`ExpressRouteServiceProvidersOperations`
* 2018-10-01: :class:`ExpressRouteServiceProvidersOperations`
* 2018-11-01: :class:`ExpressRouteServiceProvidersOperations`
+ * 2018-12-01: :class:`ExpressRouteServiceProvidersOperations`
"""
api_version = self._get_api_version('express_route_service_providers')
if api_version == '2015-06-15':
@@ -1101,6 +1177,8 @@ def express_route_service_providers(self):
from .v2018_10_01.operations import ExpressRouteServiceProvidersOperations as OperationClass
elif api_version == '2018-11-01':
from .v2018_11_01.operations import ExpressRouteServiceProvidersOperations as OperationClass
+ elif api_version == '2018-12-01':
+ from .v2018_12_01.operations import ExpressRouteServiceProvidersOperations as OperationClass
else:
raise NotImplementedError("APIVersion {} is not available".format(api_version))
return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -1115,6 +1193,7 @@ def hub_virtual_network_connections(self):
* 2018-08-01: :class:`HubVirtualNetworkConnectionsOperations`
* 2018-10-01: :class:`HubVirtualNetworkConnectionsOperations`
* 2018-11-01: :class:`HubVirtualNetworkConnectionsOperations`
+ * 2018-12-01: :class:`HubVirtualNetworkConnectionsOperations`
"""
api_version = self._get_api_version('hub_virtual_network_connections')
if api_version == '2018-04-01':
@@ -1129,6 +1208,8 @@ def hub_virtual_network_connections(self):
from .v2018_10_01.operations import HubVirtualNetworkConnectionsOperations as OperationClass
elif api_version == '2018-11-01':
from .v2018_11_01.operations import HubVirtualNetworkConnectionsOperations as OperationClass
+ elif api_version == '2018-12-01':
+ from .v2018_12_01.operations import HubVirtualNetworkConnectionsOperations as OperationClass
else:
raise NotImplementedError("APIVersion {} is not available".format(api_version))
return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -1150,6 +1231,7 @@ def inbound_nat_rules(self):
* 2018-08-01: :class:`InboundNatRulesOperations`
* 2018-10-01: :class:`InboundNatRulesOperations`
* 2018-11-01: :class:`InboundNatRulesOperations`
+ * 2018-12-01: :class:`InboundNatRulesOperations`
"""
api_version = self._get_api_version('inbound_nat_rules')
if api_version == '2017-06-01':
@@ -1178,6 +1260,8 @@ def inbound_nat_rules(self):
from .v2018_10_01.operations import InboundNatRulesOperations as OperationClass
elif api_version == '2018-11-01':
from .v2018_11_01.operations import InboundNatRulesOperations as OperationClass
+ elif api_version == '2018-12-01':
+ from .v2018_12_01.operations import InboundNatRulesOperations as OperationClass
else:
raise NotImplementedError("APIVersion {} is not available".format(api_version))
return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -1189,6 +1273,7 @@ def interface_endpoints(self):
* 2018-08-01: :class:`InterfaceEndpointsOperations`
* 2018-10-01: :class:`InterfaceEndpointsOperations`
* 2018-11-01: :class:`InterfaceEndpointsOperations`
+ * 2018-12-01: :class:`InterfaceEndpointsOperations`
"""
api_version = self._get_api_version('interface_endpoints')
if api_version == '2018-08-01':
@@ -1197,6 +1282,8 @@ def interface_endpoints(self):
from .v2018_10_01.operations import InterfaceEndpointsOperations as OperationClass
elif api_version == '2018-11-01':
from .v2018_11_01.operations import InterfaceEndpointsOperations as OperationClass
+ elif api_version == '2018-12-01':
+ from .v2018_12_01.operations import InterfaceEndpointsOperations as OperationClass
else:
raise NotImplementedError("APIVersion {} is not available".format(api_version))
return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -1218,6 +1305,7 @@ def load_balancer_backend_address_pools(self):
* 2018-08-01: :class:`LoadBalancerBackendAddressPoolsOperations`
* 2018-10-01: :class:`LoadBalancerBackendAddressPoolsOperations`
* 2018-11-01: :class:`LoadBalancerBackendAddressPoolsOperations`
+ * 2018-12-01: :class:`LoadBalancerBackendAddressPoolsOperations`
"""
api_version = self._get_api_version('load_balancer_backend_address_pools')
if api_version == '2017-06-01':
@@ -1246,6 +1334,8 @@ def load_balancer_backend_address_pools(self):
from .v2018_10_01.operations import LoadBalancerBackendAddressPoolsOperations as OperationClass
elif api_version == '2018-11-01':
from .v2018_11_01.operations import LoadBalancerBackendAddressPoolsOperations as OperationClass
+ elif api_version == '2018-12-01':
+ from .v2018_12_01.operations import LoadBalancerBackendAddressPoolsOperations as OperationClass
else:
raise NotImplementedError("APIVersion {} is not available".format(api_version))
return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -1267,6 +1357,7 @@ def load_balancer_frontend_ip_configurations(self):
* 2018-08-01: :class:`LoadBalancerFrontendIPConfigurationsOperations`
* 2018-10-01: :class:`LoadBalancerFrontendIPConfigurationsOperations`
* 2018-11-01: :class:`LoadBalancerFrontendIPConfigurationsOperations`
+ * 2018-12-01: :class:`LoadBalancerFrontendIPConfigurationsOperations`
"""
api_version = self._get_api_version('load_balancer_frontend_ip_configurations')
if api_version == '2017-06-01':
@@ -1295,6 +1386,8 @@ def load_balancer_frontend_ip_configurations(self):
from .v2018_10_01.operations import LoadBalancerFrontendIPConfigurationsOperations as OperationClass
elif api_version == '2018-11-01':
from .v2018_11_01.operations import LoadBalancerFrontendIPConfigurationsOperations as OperationClass
+ elif api_version == '2018-12-01':
+ from .v2018_12_01.operations import LoadBalancerFrontendIPConfigurationsOperations as OperationClass
else:
raise NotImplementedError("APIVersion {} is not available".format(api_version))
return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -1316,6 +1409,7 @@ def load_balancer_load_balancing_rules(self):
* 2018-08-01: :class:`LoadBalancerLoadBalancingRulesOperations`
* 2018-10-01: :class:`LoadBalancerLoadBalancingRulesOperations`
* 2018-11-01: :class:`LoadBalancerLoadBalancingRulesOperations`
+ * 2018-12-01: :class:`LoadBalancerLoadBalancingRulesOperations`
"""
api_version = self._get_api_version('load_balancer_load_balancing_rules')
if api_version == '2017-06-01':
@@ -1344,6 +1438,8 @@ def load_balancer_load_balancing_rules(self):
from .v2018_10_01.operations import LoadBalancerLoadBalancingRulesOperations as OperationClass
elif api_version == '2018-11-01':
from .v2018_11_01.operations import LoadBalancerLoadBalancingRulesOperations as OperationClass
+ elif api_version == '2018-12-01':
+ from .v2018_12_01.operations import LoadBalancerLoadBalancingRulesOperations as OperationClass
else:
raise NotImplementedError("APIVersion {} is not available".format(api_version))
return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -1365,6 +1461,7 @@ def load_balancer_network_interfaces(self):
* 2018-08-01: :class:`LoadBalancerNetworkInterfacesOperations`
* 2018-10-01: :class:`LoadBalancerNetworkInterfacesOperations`
* 2018-11-01: :class:`LoadBalancerNetworkInterfacesOperations`
+ * 2018-12-01: :class:`LoadBalancerNetworkInterfacesOperations`
"""
api_version = self._get_api_version('load_balancer_network_interfaces')
if api_version == '2017-06-01':
@@ -1393,6 +1490,8 @@ def load_balancer_network_interfaces(self):
from .v2018_10_01.operations import LoadBalancerNetworkInterfacesOperations as OperationClass
elif api_version == '2018-11-01':
from .v2018_11_01.operations import LoadBalancerNetworkInterfacesOperations as OperationClass
+ elif api_version == '2018-12-01':
+ from .v2018_12_01.operations import LoadBalancerNetworkInterfacesOperations as OperationClass
else:
raise NotImplementedError("APIVersion {} is not available".format(api_version))
return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -1404,6 +1503,7 @@ def load_balancer_outbound_rules(self):
* 2018-08-01: :class:`LoadBalancerOutboundRulesOperations`
* 2018-10-01: :class:`LoadBalancerOutboundRulesOperations`
* 2018-11-01: :class:`LoadBalancerOutboundRulesOperations`
+ * 2018-12-01: :class:`LoadBalancerOutboundRulesOperations`
"""
api_version = self._get_api_version('load_balancer_outbound_rules')
if api_version == '2018-08-01':
@@ -1412,6 +1512,8 @@ def load_balancer_outbound_rules(self):
from .v2018_10_01.operations import LoadBalancerOutboundRulesOperations as OperationClass
elif api_version == '2018-11-01':
from .v2018_11_01.operations import LoadBalancerOutboundRulesOperations as OperationClass
+ elif api_version == '2018-12-01':
+ from .v2018_12_01.operations import LoadBalancerOutboundRulesOperations as OperationClass
else:
raise NotImplementedError("APIVersion {} is not available".format(api_version))
return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -1433,6 +1535,7 @@ def load_balancer_probes(self):
* 2018-08-01: :class:`LoadBalancerProbesOperations`
* 2018-10-01: :class:`LoadBalancerProbesOperations`
* 2018-11-01: :class:`LoadBalancerProbesOperations`
+ * 2018-12-01: :class:`LoadBalancerProbesOperations`
"""
api_version = self._get_api_version('load_balancer_probes')
if api_version == '2017-06-01':
@@ -1461,6 +1564,8 @@ def load_balancer_probes(self):
from .v2018_10_01.operations import LoadBalancerProbesOperations as OperationClass
elif api_version == '2018-11-01':
from .v2018_11_01.operations import LoadBalancerProbesOperations as OperationClass
+ elif api_version == '2018-12-01':
+ from .v2018_12_01.operations import LoadBalancerProbesOperations as OperationClass
else:
raise NotImplementedError("APIVersion {} is not available".format(api_version))
return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -1486,6 +1591,7 @@ def load_balancers(self):
* 2018-08-01: :class:`LoadBalancersOperations`
* 2018-10-01: :class:`LoadBalancersOperations`
* 2018-11-01: :class:`LoadBalancersOperations`
+ * 2018-12-01: :class:`LoadBalancersOperations`
"""
api_version = self._get_api_version('load_balancers')
if api_version == '2015-06-15':
@@ -1522,6 +1628,8 @@ def load_balancers(self):
from .v2018_10_01.operations import LoadBalancersOperations as OperationClass
elif api_version == '2018-11-01':
from .v2018_11_01.operations import LoadBalancersOperations as OperationClass
+ elif api_version == '2018-12-01':
+ from .v2018_12_01.operations import LoadBalancersOperations as OperationClass
else:
raise NotImplementedError("APIVersion {} is not available".format(api_version))
return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -1547,6 +1655,7 @@ def local_network_gateways(self):
* 2018-08-01: :class:`LocalNetworkGatewaysOperations`
* 2018-10-01: :class:`LocalNetworkGatewaysOperations`
* 2018-11-01: :class:`LocalNetworkGatewaysOperations`
+ * 2018-12-01: :class:`LocalNetworkGatewaysOperations`
"""
api_version = self._get_api_version('local_network_gateways')
if api_version == '2015-06-15':
@@ -1583,6 +1692,8 @@ def local_network_gateways(self):
from .v2018_10_01.operations import LocalNetworkGatewaysOperations as OperationClass
elif api_version == '2018-11-01':
from .v2018_11_01.operations import LocalNetworkGatewaysOperations as OperationClass
+ elif api_version == '2018-12-01':
+ from .v2018_12_01.operations import LocalNetworkGatewaysOperations as OperationClass
else:
raise NotImplementedError("APIVersion {} is not available".format(api_version))
return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -1604,6 +1715,7 @@ def network_interface_ip_configurations(self):
* 2018-08-01: :class:`NetworkInterfaceIPConfigurationsOperations`
* 2018-10-01: :class:`NetworkInterfaceIPConfigurationsOperations`
* 2018-11-01: :class:`NetworkInterfaceIPConfigurationsOperations`
+ * 2018-12-01: :class:`NetworkInterfaceIPConfigurationsOperations`
"""
api_version = self._get_api_version('network_interface_ip_configurations')
if api_version == '2017-06-01':
@@ -1632,6 +1744,8 @@ def network_interface_ip_configurations(self):
from .v2018_10_01.operations import NetworkInterfaceIPConfigurationsOperations as OperationClass
elif api_version == '2018-11-01':
from .v2018_11_01.operations import NetworkInterfaceIPConfigurationsOperations as OperationClass
+ elif api_version == '2018-12-01':
+ from .v2018_12_01.operations import NetworkInterfaceIPConfigurationsOperations as OperationClass
else:
raise NotImplementedError("APIVersion {} is not available".format(api_version))
return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -1653,6 +1767,7 @@ def network_interface_load_balancers(self):
* 2018-08-01: :class:`NetworkInterfaceLoadBalancersOperations`
* 2018-10-01: :class:`NetworkInterfaceLoadBalancersOperations`
* 2018-11-01: :class:`NetworkInterfaceLoadBalancersOperations`
+ * 2018-12-01: :class:`NetworkInterfaceLoadBalancersOperations`
"""
api_version = self._get_api_version('network_interface_load_balancers')
if api_version == '2017-06-01':
@@ -1681,6 +1796,8 @@ def network_interface_load_balancers(self):
from .v2018_10_01.operations import NetworkInterfaceLoadBalancersOperations as OperationClass
elif api_version == '2018-11-01':
from .v2018_11_01.operations import NetworkInterfaceLoadBalancersOperations as OperationClass
+ elif api_version == '2018-12-01':
+ from .v2018_12_01.operations import NetworkInterfaceLoadBalancersOperations as OperationClass
else:
raise NotImplementedError("APIVersion {} is not available".format(api_version))
return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -1692,6 +1809,7 @@ def network_interface_tap_configurations(self):
* 2018-08-01: :class:`NetworkInterfaceTapConfigurationsOperations`
* 2018-10-01: :class:`NetworkInterfaceTapConfigurationsOperations`
* 2018-11-01: :class:`NetworkInterfaceTapConfigurationsOperations`
+ * 2018-12-01: :class:`NetworkInterfaceTapConfigurationsOperations`
"""
api_version = self._get_api_version('network_interface_tap_configurations')
if api_version == '2018-08-01':
@@ -1700,6 +1818,8 @@ def network_interface_tap_configurations(self):
from .v2018_10_01.operations import NetworkInterfaceTapConfigurationsOperations as OperationClass
elif api_version == '2018-11-01':
from .v2018_11_01.operations import NetworkInterfaceTapConfigurationsOperations as OperationClass
+ elif api_version == '2018-12-01':
+ from .v2018_12_01.operations import NetworkInterfaceTapConfigurationsOperations as OperationClass
else:
raise NotImplementedError("APIVersion {} is not available".format(api_version))
return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -1725,6 +1845,7 @@ def network_interfaces(self):
* 2018-08-01: :class:`NetworkInterfacesOperations`
* 2018-10-01: :class:`NetworkInterfacesOperations`
* 2018-11-01: :class:`NetworkInterfacesOperations`
+ * 2018-12-01: :class:`NetworkInterfacesOperations`
"""
api_version = self._get_api_version('network_interfaces')
if api_version == '2015-06-15':
@@ -1761,6 +1882,8 @@ def network_interfaces(self):
from .v2018_10_01.operations import NetworkInterfacesOperations as OperationClass
elif api_version == '2018-11-01':
from .v2018_11_01.operations import NetworkInterfacesOperations as OperationClass
+ elif api_version == '2018-12-01':
+ from .v2018_12_01.operations import NetworkInterfacesOperations as OperationClass
else:
raise NotImplementedError("APIVersion {} is not available".format(api_version))
return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -1772,6 +1895,7 @@ def network_profiles(self):
* 2018-08-01: :class:`NetworkProfilesOperations`
* 2018-10-01: :class:`NetworkProfilesOperations`
* 2018-11-01: :class:`NetworkProfilesOperations`
+ * 2018-12-01: :class:`NetworkProfilesOperations`
"""
api_version = self._get_api_version('network_profiles')
if api_version == '2018-08-01':
@@ -1780,6 +1904,8 @@ def network_profiles(self):
from .v2018_10_01.operations import NetworkProfilesOperations as OperationClass
elif api_version == '2018-11-01':
from .v2018_11_01.operations import NetworkProfilesOperations as OperationClass
+ elif api_version == '2018-12-01':
+ from .v2018_12_01.operations import NetworkProfilesOperations as OperationClass
else:
raise NotImplementedError("APIVersion {} is not available".format(api_version))
return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -1805,6 +1931,7 @@ def network_security_groups(self):
* 2018-08-01: :class:`NetworkSecurityGroupsOperations`
* 2018-10-01: :class:`NetworkSecurityGroupsOperations`
* 2018-11-01: :class:`NetworkSecurityGroupsOperations`
+ * 2018-12-01: :class:`NetworkSecurityGroupsOperations`
"""
api_version = self._get_api_version('network_security_groups')
if api_version == '2015-06-15':
@@ -1841,6 +1968,8 @@ def network_security_groups(self):
from .v2018_10_01.operations import NetworkSecurityGroupsOperations as OperationClass
elif api_version == '2018-11-01':
from .v2018_11_01.operations import NetworkSecurityGroupsOperations as OperationClass
+ elif api_version == '2018-12-01':
+ from .v2018_12_01.operations import NetworkSecurityGroupsOperations as OperationClass
else:
raise NotImplementedError("APIVersion {} is not available".format(api_version))
return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -1865,6 +1994,7 @@ def network_watchers(self):
* 2018-08-01: :class:`NetworkWatchersOperations`
* 2018-10-01: :class:`NetworkWatchersOperations`
* 2018-11-01: :class:`NetworkWatchersOperations`
+ * 2018-12-01: :class:`NetworkWatchersOperations`
"""
api_version = self._get_api_version('network_watchers')
if api_version == '2016-09-01':
@@ -1899,6 +2029,8 @@ def network_watchers(self):
from .v2018_10_01.operations import NetworkWatchersOperations as OperationClass
elif api_version == '2018-11-01':
from .v2018_11_01.operations import NetworkWatchersOperations as OperationClass
+ elif api_version == '2018-12-01':
+ from .v2018_12_01.operations import NetworkWatchersOperations as OperationClass
else:
raise NotImplementedError("APIVersion {} is not available".format(api_version))
return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -1918,6 +2050,7 @@ def operations(self):
* 2018-08-01: :class:`Operations`
* 2018-10-01: :class:`Operations`
* 2018-11-01: :class:`Operations`
+ * 2018-12-01: :class:`Operations`
"""
api_version = self._get_api_version('operations')
if api_version == '2017-09-01':
@@ -1942,6 +2075,8 @@ def operations(self):
from .v2018_10_01.operations import Operations as OperationClass
elif api_version == '2018-11-01':
from .v2018_11_01.operations import Operations as OperationClass
+ elif api_version == '2018-12-01':
+ from .v2018_12_01.operations import Operations as OperationClass
else:
raise NotImplementedError("APIVersion {} is not available".format(api_version))
return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -1966,6 +2101,7 @@ def packet_captures(self):
* 2018-08-01: :class:`PacketCapturesOperations`
* 2018-10-01: :class:`PacketCapturesOperations`
* 2018-11-01: :class:`PacketCapturesOperations`
+ * 2018-12-01: :class:`PacketCapturesOperations`
"""
api_version = self._get_api_version('packet_captures')
if api_version == '2016-09-01':
@@ -2000,6 +2136,8 @@ def packet_captures(self):
from .v2018_10_01.operations import PacketCapturesOperations as OperationClass
elif api_version == '2018-11-01':
from .v2018_11_01.operations import PacketCapturesOperations as OperationClass
+ elif api_version == '2018-12-01':
+ from .v2018_12_01.operations import PacketCapturesOperations as OperationClass
else:
raise NotImplementedError("APIVersion {} is not available".format(api_version))
return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -2025,6 +2163,7 @@ def public_ip_addresses(self):
* 2018-08-01: :class:`PublicIPAddressesOperations`
* 2018-10-01: :class:`PublicIPAddressesOperations`
* 2018-11-01: :class:`PublicIPAddressesOperations`
+ * 2018-12-01: :class:`PublicIPAddressesOperations`
"""
api_version = self._get_api_version('public_ip_addresses')
if api_version == '2015-06-15':
@@ -2061,6 +2200,8 @@ def public_ip_addresses(self):
from .v2018_10_01.operations import PublicIPAddressesOperations as OperationClass
elif api_version == '2018-11-01':
from .v2018_11_01.operations import PublicIPAddressesOperations as OperationClass
+ elif api_version == '2018-12-01':
+ from .v2018_12_01.operations import PublicIPAddressesOperations as OperationClass
else:
raise NotImplementedError("APIVersion {} is not available".format(api_version))
return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -2073,6 +2214,7 @@ def public_ip_prefixes(self):
* 2018-08-01: :class:`PublicIPPrefixesOperations`
* 2018-10-01: :class:`PublicIPPrefixesOperations`
* 2018-11-01: :class:`PublicIPPrefixesOperations`
+ * 2018-12-01: :class:`PublicIPPrefixesOperations`
"""
api_version = self._get_api_version('public_ip_prefixes')
if api_version == '2018-07-01':
@@ -2083,6 +2225,8 @@ def public_ip_prefixes(self):
from .v2018_10_01.operations import PublicIPPrefixesOperations as OperationClass
elif api_version == '2018-11-01':
from .v2018_11_01.operations import PublicIPPrefixesOperations as OperationClass
+ elif api_version == '2018-12-01':
+ from .v2018_12_01.operations import PublicIPPrefixesOperations as OperationClass
else:
raise NotImplementedError("APIVersion {} is not available".format(api_version))
return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -2106,6 +2250,7 @@ def route_filter_rules(self):
* 2018-08-01: :class:`RouteFilterRulesOperations`
* 2018-10-01: :class:`RouteFilterRulesOperations`
* 2018-11-01: :class:`RouteFilterRulesOperations`
+ * 2018-12-01: :class:`RouteFilterRulesOperations`
"""
api_version = self._get_api_version('route_filter_rules')
if api_version == '2016-12-01':
@@ -2138,6 +2283,8 @@ def route_filter_rules(self):
from .v2018_10_01.operations import RouteFilterRulesOperations as OperationClass
elif api_version == '2018-11-01':
from .v2018_11_01.operations import RouteFilterRulesOperations as OperationClass
+ elif api_version == '2018-12-01':
+ from .v2018_12_01.operations import RouteFilterRulesOperations as OperationClass
else:
raise NotImplementedError("APIVersion {} is not available".format(api_version))
return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -2161,6 +2308,7 @@ def route_filters(self):
* 2018-08-01: :class:`RouteFiltersOperations`
* 2018-10-01: :class:`RouteFiltersOperations`
* 2018-11-01: :class:`RouteFiltersOperations`
+ * 2018-12-01: :class:`RouteFiltersOperations`
"""
api_version = self._get_api_version('route_filters')
if api_version == '2016-12-01':
@@ -2193,6 +2341,8 @@ def route_filters(self):
from .v2018_10_01.operations import RouteFiltersOperations as OperationClass
elif api_version == '2018-11-01':
from .v2018_11_01.operations import RouteFiltersOperations as OperationClass
+ elif api_version == '2018-12-01':
+ from .v2018_12_01.operations import RouteFiltersOperations as OperationClass
else:
raise NotImplementedError("APIVersion {} is not available".format(api_version))
return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -2218,6 +2368,7 @@ def route_tables(self):
* 2018-08-01: :class:`RouteTablesOperations`
* 2018-10-01: :class:`RouteTablesOperations`
* 2018-11-01: :class:`RouteTablesOperations`
+ * 2018-12-01: :class:`RouteTablesOperations`
"""
api_version = self._get_api_version('route_tables')
if api_version == '2015-06-15':
@@ -2254,6 +2405,8 @@ def route_tables(self):
from .v2018_10_01.operations import RouteTablesOperations as OperationClass
elif api_version == '2018-11-01':
from .v2018_11_01.operations import RouteTablesOperations as OperationClass
+ elif api_version == '2018-12-01':
+ from .v2018_12_01.operations import RouteTablesOperations as OperationClass
else:
raise NotImplementedError("APIVersion {} is not available".format(api_version))
return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -2279,6 +2432,7 @@ def routes(self):
* 2018-08-01: :class:`RoutesOperations`
* 2018-10-01: :class:`RoutesOperations`
* 2018-11-01: :class:`RoutesOperations`
+ * 2018-12-01: :class:`RoutesOperations`
"""
api_version = self._get_api_version('routes')
if api_version == '2015-06-15':
@@ -2315,6 +2469,8 @@ def routes(self):
from .v2018_10_01.operations import RoutesOperations as OperationClass
elif api_version == '2018-11-01':
from .v2018_11_01.operations import RoutesOperations as OperationClass
+ elif api_version == '2018-12-01':
+ from .v2018_12_01.operations import RoutesOperations as OperationClass
else:
raise NotImplementedError("APIVersion {} is not available".format(api_version))
return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -2340,6 +2496,7 @@ def security_rules(self):
* 2018-08-01: :class:`SecurityRulesOperations`
* 2018-10-01: :class:`SecurityRulesOperations`
* 2018-11-01: :class:`SecurityRulesOperations`
+ * 2018-12-01: :class:`SecurityRulesOperations`
"""
api_version = self._get_api_version('security_rules')
if api_version == '2015-06-15':
@@ -2376,6 +2533,8 @@ def security_rules(self):
from .v2018_10_01.operations import SecurityRulesOperations as OperationClass
elif api_version == '2018-11-01':
from .v2018_11_01.operations import SecurityRulesOperations as OperationClass
+ elif api_version == '2018-12-01':
+ from .v2018_12_01.operations import SecurityRulesOperations as OperationClass
else:
raise NotImplementedError("APIVersion {} is not available".format(api_version))
return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -2388,6 +2547,7 @@ def service_endpoint_policies(self):
* 2018-08-01: :class:`ServiceEndpointPoliciesOperations`
* 2018-10-01: :class:`ServiceEndpointPoliciesOperations`
* 2018-11-01: :class:`ServiceEndpointPoliciesOperations`
+ * 2018-12-01: :class:`ServiceEndpointPoliciesOperations`
"""
api_version = self._get_api_version('service_endpoint_policies')
if api_version == '2018-07-01':
@@ -2398,6 +2558,8 @@ def service_endpoint_policies(self):
from .v2018_10_01.operations import ServiceEndpointPoliciesOperations as OperationClass
elif api_version == '2018-11-01':
from .v2018_11_01.operations import ServiceEndpointPoliciesOperations as OperationClass
+ elif api_version == '2018-12-01':
+ from .v2018_12_01.operations import ServiceEndpointPoliciesOperations as OperationClass
else:
raise NotImplementedError("APIVersion {} is not available".format(api_version))
return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -2410,6 +2572,7 @@ def service_endpoint_policy_definitions(self):
* 2018-08-01: :class:`ServiceEndpointPolicyDefinitionsOperations`
* 2018-10-01: :class:`ServiceEndpointPolicyDefinitionsOperations`
* 2018-11-01: :class:`ServiceEndpointPolicyDefinitionsOperations`
+ * 2018-12-01: :class:`ServiceEndpointPolicyDefinitionsOperations`
"""
api_version = self._get_api_version('service_endpoint_policy_definitions')
if api_version == '2018-07-01':
@@ -2420,6 +2583,8 @@ def service_endpoint_policy_definitions(self):
from .v2018_10_01.operations import ServiceEndpointPolicyDefinitionsOperations as OperationClass
elif api_version == '2018-11-01':
from .v2018_11_01.operations import ServiceEndpointPolicyDefinitionsOperations as OperationClass
+ elif api_version == '2018-12-01':
+ from .v2018_12_01.operations import ServiceEndpointPolicyDefinitionsOperations as OperationClass
else:
raise NotImplementedError("APIVersion {} is not available".format(api_version))
return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -2445,6 +2610,7 @@ def subnets(self):
* 2018-08-01: :class:`SubnetsOperations`
* 2018-10-01: :class:`SubnetsOperations`
* 2018-11-01: :class:`SubnetsOperations`
+ * 2018-12-01: :class:`SubnetsOperations`
"""
api_version = self._get_api_version('subnets')
if api_version == '2015-06-15':
@@ -2481,6 +2647,8 @@ def subnets(self):
from .v2018_10_01.operations import SubnetsOperations as OperationClass
elif api_version == '2018-11-01':
from .v2018_11_01.operations import SubnetsOperations as OperationClass
+ elif api_version == '2018-12-01':
+ from .v2018_12_01.operations import SubnetsOperations as OperationClass
else:
raise NotImplementedError("APIVersion {} is not available".format(api_version))
return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -2506,6 +2674,7 @@ def usages(self):
* 2018-08-01: :class:`UsagesOperations`
* 2018-10-01: :class:`UsagesOperations`
* 2018-11-01: :class:`UsagesOperations`
+ * 2018-12-01: :class:`UsagesOperations`
"""
api_version = self._get_api_version('usages')
if api_version == '2015-06-15':
@@ -2542,6 +2711,8 @@ def usages(self):
from .v2018_10_01.operations import UsagesOperations as OperationClass
elif api_version == '2018-11-01':
from .v2018_11_01.operations import UsagesOperations as OperationClass
+ elif api_version == '2018-12-01':
+ from .v2018_12_01.operations import UsagesOperations as OperationClass
else:
raise NotImplementedError("APIVersion {} is not available".format(api_version))
return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -2556,6 +2727,7 @@ def virtual_hubs(self):
* 2018-08-01: :class:`VirtualHubsOperations`
* 2018-10-01: :class:`VirtualHubsOperations`
* 2018-11-01: :class:`VirtualHubsOperations`
+ * 2018-12-01: :class:`VirtualHubsOperations`
"""
api_version = self._get_api_version('virtual_hubs')
if api_version == '2018-04-01':
@@ -2570,6 +2742,8 @@ def virtual_hubs(self):
from .v2018_10_01.operations import VirtualHubsOperations as OperationClass
elif api_version == '2018-11-01':
from .v2018_11_01.operations import VirtualHubsOperations as OperationClass
+ elif api_version == '2018-12-01':
+ from .v2018_12_01.operations import VirtualHubsOperations as OperationClass
else:
raise NotImplementedError("APIVersion {} is not available".format(api_version))
return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -2595,6 +2769,7 @@ def virtual_network_gateway_connections(self):
* 2018-08-01: :class:`VirtualNetworkGatewayConnectionsOperations`
* 2018-10-01: :class:`VirtualNetworkGatewayConnectionsOperations`
* 2018-11-01: :class:`VirtualNetworkGatewayConnectionsOperations`
+ * 2018-12-01: :class:`VirtualNetworkGatewayConnectionsOperations`
"""
api_version = self._get_api_version('virtual_network_gateway_connections')
if api_version == '2015-06-15':
@@ -2631,6 +2806,8 @@ def virtual_network_gateway_connections(self):
from .v2018_10_01.operations import VirtualNetworkGatewayConnectionsOperations as OperationClass
elif api_version == '2018-11-01':
from .v2018_11_01.operations import VirtualNetworkGatewayConnectionsOperations as OperationClass
+ elif api_version == '2018-12-01':
+ from .v2018_12_01.operations import VirtualNetworkGatewayConnectionsOperations as OperationClass
else:
raise NotImplementedError("APIVersion {} is not available".format(api_version))
return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -2656,6 +2833,7 @@ def virtual_network_gateways(self):
* 2018-08-01: :class:`VirtualNetworkGatewaysOperations`
* 2018-10-01: :class:`VirtualNetworkGatewaysOperations`
* 2018-11-01: :class:`VirtualNetworkGatewaysOperations`
+ * 2018-12-01: :class:`VirtualNetworkGatewaysOperations`
"""
api_version = self._get_api_version('virtual_network_gateways')
if api_version == '2015-06-15':
@@ -2692,6 +2870,8 @@ def virtual_network_gateways(self):
from .v2018_10_01.operations import VirtualNetworkGatewaysOperations as OperationClass
elif api_version == '2018-11-01':
from .v2018_11_01.operations import VirtualNetworkGatewaysOperations as OperationClass
+ elif api_version == '2018-12-01':
+ from .v2018_12_01.operations import VirtualNetworkGatewaysOperations as OperationClass
else:
raise NotImplementedError("APIVersion {} is not available".format(api_version))
return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -2716,6 +2896,7 @@ def virtual_network_peerings(self):
* 2018-08-01: :class:`VirtualNetworkPeeringsOperations`
* 2018-10-01: :class:`VirtualNetworkPeeringsOperations`
* 2018-11-01: :class:`VirtualNetworkPeeringsOperations`
+ * 2018-12-01: :class:`VirtualNetworkPeeringsOperations`
"""
api_version = self._get_api_version('virtual_network_peerings')
if api_version == '2016-09-01':
@@ -2750,6 +2931,8 @@ def virtual_network_peerings(self):
from .v2018_10_01.operations import VirtualNetworkPeeringsOperations as OperationClass
elif api_version == '2018-11-01':
from .v2018_11_01.operations import VirtualNetworkPeeringsOperations as OperationClass
+ elif api_version == '2018-12-01':
+ from .v2018_12_01.operations import VirtualNetworkPeeringsOperations as OperationClass
else:
raise NotImplementedError("APIVersion {} is not available".format(api_version))
return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -2761,6 +2944,7 @@ def virtual_network_taps(self):
* 2018-08-01: :class:`VirtualNetworkTapsOperations`
* 2018-10-01: :class:`VirtualNetworkTapsOperations`
* 2018-11-01: :class:`VirtualNetworkTapsOperations`
+ * 2018-12-01: :class:`VirtualNetworkTapsOperations`
"""
api_version = self._get_api_version('virtual_network_taps')
if api_version == '2018-08-01':
@@ -2769,6 +2953,8 @@ def virtual_network_taps(self):
from .v2018_10_01.operations import VirtualNetworkTapsOperations as OperationClass
elif api_version == '2018-11-01':
from .v2018_11_01.operations import VirtualNetworkTapsOperations as OperationClass
+ elif api_version == '2018-12-01':
+ from .v2018_12_01.operations import VirtualNetworkTapsOperations as OperationClass
else:
raise NotImplementedError("APIVersion {} is not available".format(api_version))
return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -2794,6 +2980,7 @@ def virtual_networks(self):
* 2018-08-01: :class:`VirtualNetworksOperations`
* 2018-10-01: :class:`VirtualNetworksOperations`
* 2018-11-01: :class:`VirtualNetworksOperations`
+ * 2018-12-01: :class:`VirtualNetworksOperations`
"""
api_version = self._get_api_version('virtual_networks')
if api_version == '2015-06-15':
@@ -2830,6 +3017,8 @@ def virtual_networks(self):
from .v2018_10_01.operations import VirtualNetworksOperations as OperationClass
elif api_version == '2018-11-01':
from .v2018_11_01.operations import VirtualNetworksOperations as OperationClass
+ elif api_version == '2018-12-01':
+ from .v2018_12_01.operations import VirtualNetworksOperations as OperationClass
else:
raise NotImplementedError("APIVersion {} is not available".format(api_version))
return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -2860,6 +3049,7 @@ def virtual_wans(self):
* 2018-08-01: :class:`VirtualWansOperations`
* 2018-10-01: :class:`VirtualWansOperations`
* 2018-11-01: :class:`VirtualWansOperations`
+ * 2018-12-01: :class:`VirtualWansOperations`
"""
api_version = self._get_api_version('virtual_wans')
if api_version == '2018-08-01':
@@ -2868,6 +3058,8 @@ def virtual_wans(self):
from .v2018_10_01.operations import VirtualWansOperations as OperationClass
elif api_version == '2018-11-01':
from .v2018_11_01.operations import VirtualWansOperations as OperationClass
+ elif api_version == '2018-12-01':
+ from .v2018_12_01.operations import VirtualWansOperations as OperationClass
else:
raise NotImplementedError("APIVersion {} is not available".format(api_version))
return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -2882,6 +3074,7 @@ def vpn_connections(self):
* 2018-08-01: :class:`VpnConnectionsOperations`
* 2018-10-01: :class:`VpnConnectionsOperations