Use this API to update nshttpparam.
499056
public static base_response update(nitro_service client, nshttpparam resource) throws Exception {
		nshttpparam updateresource = new nshttpparam();
		updateresource.dropinvalreqs = resource.dropinvalreqs;
		updateresource.markhttp09inval = resource.markhttp09inval;
		updateresource.markconnreqinval = resource.markconnreqinval;
		updateresource.insnssrvrhdr = resource.insnssrvrhdr;
		updateresource.nssrvrhdr = resource.nssrvrhdr;
		updateresource.logerrresp = resource.logerrresp;
		updateresource.conmultiplex = resource.conmultiplex;
		updateresource.maxreusepool = resource.maxreusepool;
		return updateresource.update_resource(client);
	}
687774
public static base_response update(nitro_service client, nsdhcpparams resource) throws Exception {
		nsdhcpparams updateresource = new nsdhcpparams();
		updateresource.dhcpclient = resource.dhcpclient;
		updateresource.saveroute = resource.saveroute;
		return updateresource.update_resource(client);
	}
321425
function updateUrl (cb, urlNode, options) {
  return cb(urlNode.url, options)
    .then((response) => {
      if (response) {
        Object.assign(urlNode, response)
      }
    })
    .catch(() => {
    })
}
920773
function update(req, res, next) {
  var params = {
    appId: req.params.id || req.body._id,
    forms: req.body.forms || []
  };
  forms.updateAppForms(req.connectionOptions, params, formsResultHandlers(constants.resultTypes.formProjects, req, next));
}
210238
private void addPostParams(final Request request) {
        if (webhookMethod != null) {
            request.addPostParam("WebhookMethod", webhookMethod);
        }

        if (webhookFilters != null) {
            for (String prop : webhookFilters) {
                request.addPostParam("WebhookFilters", prop);
            }
        }

        if (preWebhookUrl != null) {
            request.addPostParam("PreWebhookUrl", preWebhookUrl);
        }

        if (postWebhookUrl != null) {
            request.addPostParam("PostWebhookUrl", postWebhookUrl);
        }

        if (preWebhookRetryCount != null) {
            request.addPostParam("PreWebhookRetryCount", preWebhookRetryCount.toString());
        }

        if (postWebhookRetryCount != null) {
            request.addPostParam("PostWebhookRetryCount", postWebhookRetryCount.toString());
        }

        if (target != null) {
            request.addPostParam("Target", target.toString());
        }
    }
261173
def updateNetwork(self, data, id, headers=None, query_params=None, content_type="application/json"):
        
        uri = self.client.base_url + "/network/"+id
        return self.client.post(uri, data, headers, query_params, content_type)
183397
public static base_response update(nitro_service client, dnsparameter resource) throws Exception {
		dnsparameter updateresource = new dnsparameter();
		updateresource.retries = resource.retries;
		updateresource.minttl = resource.minttl;
		updateresource.maxttl = resource.maxttl;
		updateresource.cacherecords = resource.cacherecords;
		updateresource.namelookuppriority = resource.namelookuppriority;
		updateresource.recursion = resource.recursion;
		updateresource.resolutionorder = resource.resolutionorder;
		updateresource.dnssec = resource.dnssec;
		updateresource.maxpipeline = resource.maxpipeline;
		updateresource.dnsrootreferral = resource.dnsrootreferral;
		updateresource.dns64timeout = resource.dns64timeout;
		return updateresource.update_resource(client);
	}
333464
private void addPostParams(final Request request) {
        if (friendlyName != null) {
            request.addPostParam("FriendlyName", friendlyName);
        }

        if (ipAddress != null) {
            request.addPostParam("IpAddress", ipAddress);
        }

        if (cidrPrefixLength != null) {
            request.addPostParam("CidrPrefixLength", cidrPrefixLength.toString());
        }
    }
1085181
function updateConnectionParameters() {
      if (self.connectionWait < MAX_CONNECTION_ATTEMPT_WAIT) {
        self.connectionWait += UNSUCCESSFUL_CONNECTION_ATTEMPT_ADDITIONAL_WAIT;
      }

      if (self.openTimeout < MAX_OPEN_ATTEMPT_TIMEOUT) {
        self.openTimeout += UNSUCCESSFUL_OPEN_ATTEMPT_ADDITIONAL_TIMEOUT;
      }

      if (self.connectedTimeout < MAX_CONNECTED_ATTEMPT_TIMEOUT) {
        self.connectedTimeout += UNSUCCESSFUL_CONNECTED_ATTEMPT_ADDITIONAL_TIMEOUT;
      }

      if (self.compulsorySecure !== true) {
        self.connectionSecure = !self.connectionSecure;
      }

      self.connectionAttempts++;
    }
861087
def update_get_params(self):
        """"""
        if isinstance(self._fields, (tuple, list)):  # tuples & lists > x,y,z
            self.get_params["fields"] = ",".join([str(_) for _ in self._fields])
        elif isinstance(self._fields, str):
            self.get_params["fields"] = self._fields
924073
public void updateStreamPullUrl(UpdateStreamPullUrlRequest request) {
        checkNotNull(request, "The parameter request should NOT be null.");

        checkStringNotEmpty(request.getDomain(), "Domain should NOT be empty.");
        checkStringNotEmpty(request.getApp(), "App should NOT be empty");
        checkStringNotEmpty(request.getStream(), "Stream should NOT be empty.");
        checkStringNotEmpty(request.getPullUrl(), "PullUrl should NOT be empty.");

        InternalRequest internalRequest = createRequest(HttpMethodName.PUT, request, LIVE_DOMAIN,
                request.getDomain(), LIVE_APP, request.getApp(), LIVE_STREAM, request.getStream());
        internalRequest.addParameter("pullUrl", request.getPullUrl());
        invokeHttpClient(internalRequest, AbstractBceResponse.class);
    }
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)
731799
def _update(self, **kwargs):
        """"""
        path = self._construct_path_to_item()
        if not kwargs:
            return
        return self._http.put(path, json.dumps(kwargs))
36996
def update_http_method_params(self):
        
        url_params = {}

        if self.start:
            url_params.update(
                {"start": int(calendar.timegm(self.start.timetuple()))}
            )

        if self.stop:
            url_params.update(
                {"stop": int(calendar.timegm(self.stop.timetuple()))}
            )

        if self.probe_ids:
            url_params.update({"probe_ids": self.probe_ids})

        self.http_method_args["params"].update(url_params)
705777
def update(self, *, name=None, position=None, visibility=None):
        

        if name is None and position is None and visibility is None:
            raise ValueError('Provide at least one parameter to update')
        data = {}
        if name:
            data['name'] = name
        if position:
            data['position'] = position
        if visibility:
            data['visibility'] = visibility

        response = self.session.patch(self.build_url(''), data=data)
        if not response:
            return False

        data = response.json()
        self.name = data.get('name', self.name)
        self.position = data.get('position', self.position)
        self.visibility = data.get('visibility', self.visibility)

        return True
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);
	}
747827
protected void requestElementUpdate (String name, int index, Object value, Object oldValue)
    {
        requestElementUpdate(name, index, value, oldValue, Transport.DEFAULT);
    }