PUT /api/v2/apitoken/id
 Update the name of the specified api token

 @param id [String] ID of the API token
 @param name [String] name of the API token
 @return [Wavefront::Response]
190352
def rename(id, name)
      wf_apitoken_id?(id)
      api.put(id, { tokenID: id, tokenName: name }, 'application/json')
    end
203121
def update(self, typ, id, **kwargs):
        
        return self._load(self._request(typ, id=id, method='PUT', data=kwargs))
1098710
@PUT
    @Consumes(MediaType.APPLICATION_JSON)
    @Path("{id}")
    public SuccessResponse updateApiKey(@PathParam("id") String id, EmoApiKey emoApiKey,
                                        @Authenticated Subject subject) {
        checkArgument(emoApiKey.getId().equals(id), "Body contains conflicting API key identifier");
        return updateApiKey(id,
                new UpdateEmoApiKeyRequest()
                    .setOwner(emoApiKey.getOwner())
                    .setDescription(emoApiKey.getDescription())
                    .setAssignedRoles(emoApiKey.getRoles())
                    .setUnassignOtherRoles(true),
                subject);
    }
400741
def list_update(self, id, title):
        
        id = self.__unpack_id(id)
        params = self.__generate_params(locals(), ['id'])
        return self.__api_request('PUT', '/api/v1/lists/{0}'.format(id), params)
1011303
def update(id, body)
      wf_savedsearch_id?(id)
      raise ArgumentError unless body.is_a?(Hash)
      api.put(id, body)
    end
1296352
def save
      # If we have an id, just update our fields.
      return update! if id

      from_response client.post("/webhooks", {
        description: description,
        idModel: id_model,
        callbackURL: callback_url
      })
    end
148720
public FutureData<PushSubscription> update(String id, PushConnector connector, String name) {
        if (id == null || id.isEmpty() || connector == null) {
            throw new IllegalArgumentException("A push subscription ID and output parameters is required");
        }
        FutureData<PushSubscription> future = new FutureData<>();
        URI uri = newParams().forURL(config.newAPIEndpointURI(UPDATE));
        POST request = config.http()
                .POST(uri, new PageReader(newRequestCallback(future, new PushSubscription(), config)))
                .form("id", id);
        for (Map.Entry<String, String> e : connector.parameters().verifyAndGet().entrySet()) {
            request.form(e.getKey(), e.getValue());
        }
        if (name != null && !name.isEmpty()) {
            request.form("name", name);
        }
        performRequest(future, request);
        return future;
    }
711842
def rename(self, name):
        
        self.update(name='{} node {}'.format(name, self.nodeid))
410712
def put(self, request, id, format=None):
        
        bot = self.get_bot(id, request.user)
        serializer = BotUpdateSerializer(bot, data=request.data)
        if serializer.is_valid():
            try:
                bot = serializer.save()
            except:
                return Response(status=status.HTTP_400_BAD_REQUEST)
            else:
                return Response(BotSerializer(bot).data)
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
1123555
def update_image(self, name):
        # The `_image` is to avoid conflicts with MutableMapping.update.
        
        api = self.doapi_manager
        return api._image(api.request(self.url, method='PUT',
                                               data={"name": name})["image"])
580552
def oauth_token_show(self, id, **kwargs):
        ""
        api_path = "/api/v2/oauth/tokens/{id}.json"
        api_path = api_path.format(id=id)
        return self.call(api_path, **kwargs)
1103559
def update_ssh_key(self, name):
        # The `_ssh_key` is to avoid conflicts with MutableMapping.update.
        
        api = self.doapi_manager
        return api._ssh_key(api.request(self.url, method='PUT',
                                       data={"name": name})["ssh_key"])
564102
def update_group(self, group_id, name):
        
        parameters = {
            'name': name
        }

        url = self.TEAM_GROUPS_ID_URL % group_id

        connection = Connection(self.token)
        connection.set_url(self.production, url)
        connection.add_header('Content-Type', 'application/json')
        connection.add_params(parameters)

        return connection.patch_request()
1178964
public void serviceName_spla_id_PUT(String serviceName, Long id, OvhSpla body) throws IOException {
		String qPath = "/dedicated/server/{serviceName}/spla/{id}";
		StringBuilder sb = path(qPath, serviceName, id);
		exec(qPath, "PUT", sb.toString(), body);
	}
731653
def put(cls, id, api_key=None, **kwargs):
        """"""
        inst = cls(api_key=api_key)
        endpoint = '/'.join((cls.get_endpoint(), id))
        return inst.request('PUT', endpoint=endpoint, query_params=kwargs)
626185
def update_value(self, name, value):
        
        if name not in {'id', self.SERVICE_ENDPOINT, self.CONSUME_ENDPOINT, 'type'}:
            self._values[name] = value
164657
public void serviceName_ssl_id_PUT(String serviceName, Long id, OvhSsl body) throws IOException {
		String qPath = "/ipLoadbalancing/{serviceName}/ssl/{id}";
		StringBuilder sb = path(qPath, serviceName, id);
		exec(qPath, "PUT", sb.toString(), body);
	}