Instance depends on the API version:

           * 2018-04-01: :class:`VirtualHubsOperations<azure.mgmt.network.v2018_04_01.operations.VirtualHubsOperations>`
482672
def virtual_hubs(self):
        
        api_version = self._get_api_version('virtual_hubs')
        if api_version == '2018-04-01':
            from .v2018_04_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)))
1165129
def get_instance(self, payload):
        
        return DefaultsInstance(self._version, payload, assistant_sid=self._solution['assistant_sid'], )
1224922
protected static AbatisService getInstance(Context context, int version) {
      if (instance == null) {
         instance = new AbatisService(context, version);
      }
      return instance;
   }
201208
def interface_endpoints(self):
        
        api_version = self._get_api_version('interface_endpoints')
        if api_version == '2018-08-01':
            from .v2018_08_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)))
468592
def show_instance(instance_id, call=None, kwargs=None):
    '''
    
    '''
    if call != 'action':
        raise SaltCloudSystemExit(
            'The show_instance action must be called with -a or --action.'
        )

    params = {
        'action': 'DescribeInstances',
        'instances.1': instance_id,
        'zone': _get_specified_zone(kwargs=None, provider=get_configured_provider()),
    }
    items = query(params=params)

    if items['total_count'] == 0:
        raise SaltCloudNotFound(
            'The specified instance, \'{0}\', could not be found.'.format(instance_id)
        )

    full_node = items['instance_set'][0]
    normalized_node = _show_normalized_node(full_node)
    full_node.update(normalized_node)

    result = full_node

    return result
493183
def resource_api_version(self, resource_id):
        

        namespace = ResourceIdParser.get_namespace(resource_id)
        resource_type = ResourceIdParser.get_resource_type(resource_id)

        cache_id = namespace + resource_type

        if cache_id in self._provider_cache:
            return self._provider_cache[cache_id]

        resource_client = self.client('azure.mgmt.resource.ResourceManagementClient')
        provider = resource_client.providers.get(namespace)

        rt = next((t for t in provider.resource_types
            if StringUtils.equal(t.resource_type, resource_type)), None)

        if rt and rt.api_versions:
            versions = [v for v in rt.api_versions if 'preview' not in v.lower()]
            api_version = versions[0] if versions else rt.api_versions[0]
            self._provider_cache[cache_id] = api_version
            return api_version
1233015
def check_api_version(resource_root, min_version):
  
  if resource_root.version < min_version:
    raise Exception("API version %s is required but %s is in use."
        % (min_version, resource_root.version))
244890
def Client(api_version, *args, **kwargs):
    
    neutron_client = utils.get_client_class(
        API_NAME,
        api_version,
        API_VERSIONS,
    )
    return neutron_client(*args, **kwargs)
787263
def get_instance(self, payload):
        
        return WebhookInstance(self._version, payload, session_sid=self._solution['session_sid'], )
423238
def create_vs(self, name, ip, port, protocol, profile, pool_name):
        '''
        
        '''
        vs = self.bigIP.LocalLB.VirtualServer
        vs_def = vs.typefactory.create('Common.VirtualServerDefinition')

        vs_def.name = name
        vs_def.address = ip
        vs_def.port = port

        common_protocols = vs.typefactory.create('Common.ProtocolType')

        p = [i[0] for i in common_protocols if i[0].split('_')[1] == protocol.upper()]

        if p:
            vs_def.protocol = p
        else:
            raise CommandExecutionError('Unknown protocol')

        vs_def_seq = vs.typefactory.create('Common.VirtualServerSequence')
        vs_def_seq.item = [vs_def]

        vs_type = vs.typefactory.create(
            'LocalLB.VirtualServer.VirtualServerType'
        )
        vs_resource = vs.typefactory.create(
            'LocalLB.VirtualServer.VirtualServerResource'
        )

        vs_resource.type = vs_type.RESOURCE_TYPE_POOL
        vs_resource.default_pool_name = pool_name

        resource_seq = vs.typefactory.create(
            'LocalLB.VirtualServer.VirtualServerResourceSequence'
        )

        resource_seq.item = [vs_resource]

        vs_context = vs.typefactory.create('LocalLB.ProfileContextType')
        vs_profile = vs.typefactory.create(
            'LocalLB.VirtualServer.VirtualServerProfile'
        )

        vs_profile.profile_context = vs_context.PROFILE_CONTEXT_TYPE_ALL
        vs_profile.profile_name = protocol

        vs_profile_http = vs.typefactory.create(
            'LocalLB.VirtualServer.VirtualServerProfile'
        )
        vs_profile_http.profile_name = profile

        vs_profile_conn = vs.typefactory.create(
            'LocalLB.VirtualServer.VirtualServerProfile'
        )
        vs_profile_conn.profile_name = 'oneconnect'

        vs_profile_seq = vs.typefactory.create(
            'LocalLB.VirtualServer.VirtualServerProfileSequence'
        )
        vs_profile_seq.item = [vs_profile, vs_profile_http, vs_profile_conn]

        try:
            vs.create(definitions=vs_def_seq,
                      wildmasks=['255.255.255.255'],
                      resources=resource_seq,
                      profiles=[vs_profile_seq])
        except Exception as e:
            raise Exception(
                'Unable to create `{0}` virtual server\n\n{1}'.format(name, e)
            )
        return True
486416
def get_instance(self, payload):
        
        return MemberInstance(
            self._version,
            payload,
            service_sid=self._solution['service_sid'],
            channel_sid=self._solution['channel_sid'],
        )
1215040
def vpn_sites_configuration(self):
        
        api_version = self._get_api_version('vpn_sites_configuration')
        if api_version == '2018-04-01':
            from .v2018_04_01.operations import VpnSitesConfigurationOperations 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)))
703288
def get_instance(self, payload):
        
        return UsageInstance(self._version, payload, account_sid=self._solution['account_sid'], )
106741
def get_instance(self, payload):
        
        return TaskInstance(self._version, payload, workspace_sid=self._solution['workspace_sid'], )
313128
function determineWMSAbstract(json, version) {
	var ret = '';

	if (version == '1.3.0') {
		if (json.WMS_Capabilities.Service) {
			if (json.WMS_Capabilities.Service[0]) {
				if (json.WMS_Capabilities.Service[0].Abstract) {
					if (json.WMS_Capabilities.Service[0].Abstract[0]) {
						ret = json.WMS_Capabilities.Service[0].Abstract[0];
					}
				}
			}
		}
	} else {
		if (version == '1.1.1' || version == '1.1.0' || version == '1.0.0') {
			if (json.WMT_MS_Capabilities.Service) {
				if (json.WMT_MS_Capabilities.Service[0]) {
					if (json.WMT_MS_Capabilities.Service[0].Abstract) {
						if (json.WMT_MS_Capabilities.Service[0].Abstract[0]) {
							ret = json.WMT_MS_Capabilities.Service[0].Abstract[0];
						}
					}
				}
			}
		}
	}

	return ret;
}
489031
def vpn_gateways(self):
        
        api_version = self._get_api_version('vpn_gateways')
        if api_version == '2018-04-01':
            from .v2018_04_01.operations import VpnGatewaysOperations 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)))
851088
def available_delegations(self):
        
        api_version = self._get_api_version('available_delegations')
        if api_version == '2018-08-01':
            from .v2018_08_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)))