Use this API to update vpntrafficaction.
163463
public static base_response update(nitro_service client, vpntrafficaction resource) throws Exception {
		vpntrafficaction updateresource = new vpntrafficaction();
		updateresource.name = resource.name;
		updateresource.apptimeout = resource.apptimeout;
		updateresource.sso = resource.sso;
		updateresource.formssoaction = resource.formssoaction;
		updateresource.fta = resource.fta;
		updateresource.wanscaler = resource.wanscaler;
		updateresource.kcdaccount = resource.kcdaccount;
		updateresource.samlssoprofile = resource.samlssoprofile;
		return updateresource.update_resource(client);
	}
1200759
public static base_response update(nitro_service client, dnsaction resource) throws Exception {
		dnsaction updateresource = new dnsaction();
		updateresource.actionname = resource.actionname;
		updateresource.ipaddress = resource.ipaddress;
		updateresource.ttl = resource.ttl;
		updateresource.viewname = resource.viewname;
		updateresource.preferredloclist = resource.preferredloclist;
		return updateresource.update_resource(client);
	}
834692
def update(tournament, match, attachment, **params):
    """"""
    api.fetch(
        "PUT",
        "tournaments/%s/matches/%s/attachments/%s" % (tournament, match, attachment),
        "match_attachment",
        **params)
251648
def update_vip(self, vip, body=None):
        """"""
        return self.put(self.vip_path % (vip), body=body)
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);
	}
1246444
public static base_response update(nitro_service client, vpnformssoaction resource) throws Exception {
		vpnformssoaction updateresource = new vpnformssoaction();
		updateresource.name = resource.name;
		updateresource.actionurl = resource.actionurl;
		updateresource.userfield = resource.userfield;
		updateresource.passwdfield = resource.passwdfield;
		updateresource.ssosuccessrule = resource.ssosuccessrule;
		updateresource.responsesize = resource.responsesize;
		updateresource.namevaluepair = resource.namevaluepair;
		updateresource.nvtype = resource.nvtype;
		updateresource.submitmethod = resource.submitmethod;
		return updateresource.update_resource(client);
	}
957314
def request_param_update(self, var_id):
        """"""
        self._useV2 = self.cf.platform.get_protocol_version() >= 4
        pk = CRTPPacket()
        pk.set_header(CRTPPort.PARAM, READ_CHANNEL)
        if self._useV2:
            pk.data = struct.pack('<H', var_id)
        else:
            pk.data = struct.pack('<B', var_id)
        logger.debug('Requesting request to update param [%d]', var_id)
        self.request_queue.put(pk)
62825
def _update(self, **kwargs):
        """"""
        if 'content' in kwargs:
            content = kwargs.pop('content')
            path = self._construct_path_to_source_content()
            self._http.put(path, json.dumps({'content': content}))
        super(Resource, self)._update(**kwargs)
848144
def start_update(ref)
      if update_version == 'v2'
        raise InvalidApiVersion, 'There is more than one codebase use sfrest.update.update directly.'
      end

      update_data = { scope: 'sites', sites_type: 'code, db', sites_ref: ref }
      update(update_data)
    end
1331745
public static base_response update(nitro_service client, authenticationauthnprofile resource) throws Exception {
		authenticationauthnprofile updateresource = new authenticationauthnprofile();
		updateresource.name = resource.name;
		updateresource.authnvsname = resource.authnvsname;
		updateresource.authenticationhost = resource.authenticationhost;
		updateresource.authenticationdomain = resource.authenticationdomain;
		updateresource.authenticationlevel = resource.authenticationlevel;
		return updateresource.update_resource(client);
	}
725302
public static base_responses update(nitro_service client, vpnurl resources[]) throws Exception {
		base_responses result = null;
		if (resources != null && resources.length > 0) {
			vpnurl updateresources[] = new vpnurl[resources.length];
			for (int i=0;i<resources.length;i++){
				updateresources[i] = new vpnurl();
				updateresources[i].urlname = resources[i].urlname;
				updateresources[i].linkname = resources[i].linkname;
				updateresources[i].actualurl = resources[i].actualurl;
				updateresources[i].clientlessaccess = resources[i].clientlessaccess;
				updateresources[i].comment = resources[i].comment;
			}
			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)
507555
protected void updateApiVersion(HasMetadata hasMetadata) {
    String version = getApiVersion();
    if (hasMetadata != null && version != null && version.length() > 0) {
      String current = hasMetadata.getApiVersion();
      // lets overwrite the api version if its currently missing, the resource uses an API Group with '/'
      // or we have the default of 'v1' when using an API group version like 'build.openshift.io/v1'
      if (current == null || "v1".equals(current) || current.indexOf('/') < 0 && version.indexOf('/') > 0) {
        hasMetadata.setApiVersion(version);
      }
    }
  }
876218
public static base_response update(nitro_service client, inat resource) throws Exception {
		inat updateresource = new inat();
		updateresource.name = resource.name;
		updateresource.privateip = resource.privateip;
		updateresource.tcpproxy = resource.tcpproxy;
		updateresource.ftp = resource.ftp;
		updateresource.tftp = resource.tftp;
		updateresource.usip = resource.usip;
		updateresource.usnip = resource.usnip;
		updateresource.proxyip = resource.proxyip;
		updateresource.mode = resource.mode;
		return updateresource.update_resource(client);
	}
510190
def update(self, **kwargs):
        
        if 'useProxyServer' in kwargs and kwargs['useProxyServer'] == 'enabled':
            if 'proxyServerPool' not in kwargs:
                error = 'Missing proxyServerPool parameter value.'
                raise MissingUpdateParameter(error)
        if hasattr(self, 'useProxyServer'):
            if getattr(self, 'useProxyServer') == 'enabled' and 'proxyServerPool' not in self.__dict__:
                error = 'Missing proxyServerPool parameter value.'
                raise MissingUpdateParameter(error)

        self._update(**kwargs)

        return self
426963
public static base_response update(nitro_service client, ipv6 resource) throws Exception {
		ipv6 updateresource = new ipv6();
		updateresource.ralearning = resource.ralearning;
		updateresource.routerredirection = resource.routerredirection;
		updateresource.ndbasereachtime = resource.ndbasereachtime;
		updateresource.ndretransmissiontime = resource.ndretransmissiontime;
		updateresource.natprefix = resource.natprefix;
		updateresource.dodad = resource.dodad;
		return updateresource.update_resource(client);
	}
595156
def update(self, *args, **kwargs):
        """"""
        # first find the update_url for the provided account + hostname:
        update_url = next((r.update_url for r in
                           records(self._credentials, self._url)
                           if r.hostname == self.hostname), None)
        if update_url is None:
            LOG.warning("Could not find hostname '%s' at '%s'",
                        self.hostname, self._url)
            return None
        return update(update_url)