Use this API to update vpnurl.
489958
public static base_response update(nitro_service client, vpnurl resource) throws Exception {
		vpnurl updateresource = new vpnurl();
		updateresource.urlname = resource.urlname;
		updateresource.linkname = resource.linkname;
		updateresource.actualurl = resource.actualurl;
		updateresource.clientlessaccess = resource.clientlessaccess;
		updateresource.comment = resource.comment;
		return updateresource.update_resource(client);
	}
647488
public static base_response update(nitro_service client, rnatparam resource) throws Exception {
		rnatparam updateresource = new rnatparam();
		updateresource.tcpproxy = resource.tcpproxy;
		return updateresource.update_resource(client);
	}
814105
def update(self):
        """"""
        if self.client_mode == 'glances':
            return self.update_glances()
        elif self.client_mode == 'snmp':
            return self.update_snmp()
        else:
            self.end()
            logger.critical("Unknown server mode: {}".format(self.client_mode))
            sys.exit(2)
385110
public static base_response update(nitro_service client, aaapreauthenticationparameter resource) throws Exception {
		aaapreauthenticationparameter updateresource = new aaapreauthenticationparameter();
		updateresource.preauthenticationaction = resource.preauthenticationaction;
		updateresource.rule = resource.rule;
		updateresource.killprocess = resource.killprocess;
		updateresource.deletefiles = resource.deletefiles;
		return updateresource.update_resource(client);
	}
342813
def upgrade():
    """"""
    current_date = datetime.utcnow()

    # Add 'created' and 'updated' columns to RemoteAccount
    _add_created_updated_columns('oauthclient_remoteaccount', current_date)

    # Add 'created' and 'updated' columns to RemoteToken
    _add_created_updated_columns('oauthclient_remotetoken', current_date)

    # Add 'created' and 'updated' columns to UserIdentity
    _add_created_updated_columns('oauthclient_useridentity', current_date)
1308516
public static base_response update(nitro_service client, nsip resource) throws Exception {
		nsip updateresource = new nsip();
		updateresource.ipaddress = resource.ipaddress;
		updateresource.td = resource.td;
		updateresource.netmask = resource.netmask;
		updateresource.arp = resource.arp;
		updateresource.icmp = resource.icmp;
		updateresource.vserver = resource.vserver;
		updateresource.telnet = resource.telnet;
		updateresource.ftp = resource.ftp;
		updateresource.gui = resource.gui;
		updateresource.ssh = resource.ssh;
		updateresource.snmp = resource.snmp;
		updateresource.mgmtaccess = resource.mgmtaccess;
		updateresource.restrictaccess = resource.restrictaccess;
		updateresource.dynamicrouting = resource.dynamicrouting;
		updateresource.ospf = resource.ospf;
		updateresource.bgp = resource.bgp;
		updateresource.rip = resource.rip;
		updateresource.hostroute = resource.hostroute;
		updateresource.hostrtgw = resource.hostrtgw;
		updateresource.metric = resource.metric;
		updateresource.vserverrhilevel = resource.vserverrhilevel;
		updateresource.ospflsatype = resource.ospflsatype;
		updateresource.ospfarea = resource.ospfarea;
		updateresource.vrid = resource.vrid;
		updateresource.icmpresponse = resource.icmpresponse;
		updateresource.arpresponse = resource.arpresponse;
		return updateresource.update_resource(client);
	}
668576
def Update(self):
		

		return(clc.v2.Requests(clc.v2.API.Call('PUT','servers/%s/%s/publicIPAddresses/%s' % (self.parent.server.alias,self.parent.server.id,self.id),
						                       json.dumps({'ports': [o.ToDict() for o in self.ports],
											               'sourceRestrictions': [o.ToDict() for o in self.source_restrictions] }),
											   session=self.session),
							   alias=self.parent.server.alias,
							   session=self.session))
387200
def _update_page(self, uri, path):
        """"""
        if uri in self._pages:
            self._pages[uri].update()
        else:
            self._pages[uri] = Page(uri=uri, path=path)
914749
public static base_responses update(nitro_service client, vpnformssoaction resources[]) throws Exception {
		base_responses result = null;
		if (resources != null && resources.length > 0) {
			vpnformssoaction updateresources[] = new vpnformssoaction[resources.length];
			for (int i=0;i<resources.length;i++){
				updateresources[i] = new vpnformssoaction();
				updateresources[i].name = resources[i].name;
				updateresources[i].actionurl = resources[i].actionurl;
				updateresources[i].userfield = resources[i].userfield;
				updateresources[i].passwdfield = resources[i].passwdfield;
				updateresources[i].ssosuccessrule = resources[i].ssosuccessrule;
				updateresources[i].responsesize = resources[i].responsesize;
				updateresources[i].namevaluepair = resources[i].namevaluepair;
				updateresources[i].nvtype = resources[i].nvtype;
				updateresources[i].submitmethod = resources[i].submitmethod;
			}
			result = update_bulk_request(client, updateresources);
		}
		return result;
	}
894582
async def update_version(self):
        """"""
        get_version = GetVersion(pyvlx=self)
        await get_version.do_api_call()
        if not get_version.success:
            raise PyVLXException("Unable to retrieve version")
        self.version = get_version.version
        get_protocol_version = GetProtocolVersion(pyvlx=self)
        await get_protocol_version.do_api_call()
        if not get_protocol_version.success:
            raise PyVLXException("Unable to retrieve protocol version")
        self.protocol_version = get_protocol_version.version
        PYVLXLOG.warning(
            "Connected to: %s, protocol version: %s",
            self.version, self.protocol_version)
537205
def update_vcl(self, service_id, version_number, name_key, **kwargs):
		""""""
		body = self._formdata(kwargs, FastlyVCL.FIELDS)
		content = self._fetch("/service/%s/version/%d/vcl/%s" % (service_id, version_number, name_key), method="PUT", body=body)
		return FastlyVCL(self, content)
1279202
def _update_api_client(self, api_parent_class=None):
        """"""
        clients = ([self.api_clients[api_parent_class]]
                   if api_parent_class else self.api_clients.values())

        for api_client in clients:
            api_client.configuration.host = (self.config.get('host') or
                                             api_client.configuration.host)
            api_client.configuration.api_key['Authorization'] = self.config['api_key']
918259
public static base_response update(nitro_service client, vpnclientlessaccesspolicy resource) throws Exception {
		vpnclientlessaccesspolicy updateresource = new vpnclientlessaccesspolicy();
		updateresource.name = resource.name;
		updateresource.rule = resource.rule;
		updateresource.profilename = resource.profilename;
		return updateresource.update_resource(client);
	}
75159
def update_ipsecpolicy(self, ipsecpolicy, body=None):
        """"""
        return self.put(self.ipsecpolicy_path % (ipsecpolicy), body=body)
275925
def update(self, data):
        """"""
        self.name = data["name"]
        self.description = data['description']
        self.win_index = data['win_index']
        # Other attributes are optional
        if conf.use_winpcapy:
            self._update_pcapdata()
        try:
            self.ip = socket.inet_ntoa(get_if_raw_addr(data['guid']))
        except (KeyError, AttributeError, NameError):
            pass
        try:
            self.mac = data['mac']
        except KeyError:
            pass
142523
public static base_responses update(nitro_service client, nsip resources[]) throws Exception {
		base_responses result = null;
		if (resources != null && resources.length > 0) {
			nsip updateresources[] = new nsip[resources.length];
			for (int i=0;i<resources.length;i++){
				updateresources[i] = new nsip();
				updateresources[i].ipaddress = resources[i].ipaddress;
				updateresources[i].td = resources[i].td;
				updateresources[i].netmask = resources[i].netmask;
				updateresources[i].arp = resources[i].arp;
				updateresources[i].icmp = resources[i].icmp;
				updateresources[i].vserver = resources[i].vserver;
				updateresources[i].telnet = resources[i].telnet;
				updateresources[i].ftp = resources[i].ftp;
				updateresources[i].gui = resources[i].gui;
				updateresources[i].ssh = resources[i].ssh;
				updateresources[i].snmp = resources[i].snmp;
				updateresources[i].mgmtaccess = resources[i].mgmtaccess;
				updateresources[i].restrictaccess = resources[i].restrictaccess;
				updateresources[i].dynamicrouting = resources[i].dynamicrouting;
				updateresources[i].ospf = resources[i].ospf;
				updateresources[i].bgp = resources[i].bgp;
				updateresources[i].rip = resources[i].rip;
				updateresources[i].hostroute = resources[i].hostroute;
				updateresources[i].hostrtgw = resources[i].hostrtgw;
				updateresources[i].metric = resources[i].metric;
				updateresources[i].vserverrhilevel = resources[i].vserverrhilevel;
				updateresources[i].ospflsatype = resources[i].ospflsatype;
				updateresources[i].ospfarea = resources[i].ospfarea;
				updateresources[i].vrid = resources[i].vrid;
				updateresources[i].icmpresponse = resources[i].icmpresponse;
				updateresources[i].arpresponse = resources[i].arpresponse;
			}
			result = update_bulk_request(client, updateresources);
		}
		return result;
	}
90853
def _update_from_api_repr(self, resource):
        """"""
        self.destination = resource["destination"]
        self.filter_ = resource.get("filter")
        self._writer_identity = resource.get("writerIdentity")