https://developer.zendesk.com/rest_api/docs/chat/skills#update-skill-by-name
547183
def skills_name_update(self, name, data, **kwargs):
        ""
        api_path = "/api/v2/skills/name/{name}"
        api_path = api_path.format(name=name)
        return self.call(api_path, method="PUT", data=data, **kwargs)
469777
async function update (nameId, target, options = {}) {
  const opt = R.merge(this.Ae.defaults, options)
  const nameUpdateTx = await this.nameUpdateTx(R.merge(opt, {
    nameId: nameId,
    accountId: await this.address(),
    pointers: [R.fromPairs([['id', target], ['key', classify(target)]])]
  }))

  return this.send(nameUpdateTx, opt)
}
206938
def update_todo_list(self, list_id, name, description, milestone_id=None,
        private=None, tracked=None):
        
        path = '/todos/update_list/%u' % list_id
        req = ET.Element('request')
        list_ = ET.SubElement('list')
        ET.SubElement(list_, 'name').text = str(name)
        ET.SubElement(list_, 'description').text = str(description)
        if milestone_id is not None:
            ET.SubElement(list_, 'milestone_id').text = str(int(milestone_id))
        if private is not None:
            ET.SubElement(list_, 'private').text = str(bool(private)).lower()
        if tracked is not None:
            ET.SubElement(list_, 'tracked').text = str(bool(tracked)).lower()
        return self._request(path, req)
1352804
def update(self, name, modifiers):
        """"""
        self.update_name(name)
        self.modifiers = modifiers
44851
function update(form) {
      // refuse to work with invalid data
      if (!vm.clientModelDoc._id || form && !form.$valid) {
        return;
      }

      ClientModelDocService.update(vm.clientModelDoc)
        .then(updateClientModelDocSuccess)
        .catch(updateClientModelDocCatch);

      function updateClientModelDocSuccess(updatedClientModelDoc) {
        // update the display name after successful save
        vm.displayName = updatedClientModelDoc.name;
        Toast.show({text: 'ClientModelDoc ' + vm.displayName + ' updated'});
        if (form) {
          form.$setPristine();
        }
      }

      function updateClientModelDocCatch(err) {
        Toast.show({
          type: 'warn',
          text: 'Error while updating ClientModelDoc ' + vm.displayName,
          link: {state: $state.$current, params: $stateParams}
        });

        if (form && err) {
          form.setResponseErrors(err.data);
        }
      }
    }
1027216
def update(self, auth, resource, desc={}, defer=False):
        
        return self._call('update', auth, [resource, desc], defer)
761060
def skill_delete(self, skill_id, **kwargs):
        ""
        api_path = "/api/v2/skills/{skill_id}"
        api_path = api_path.format(skill_id=skill_id)
        return self.call(api_path, method="DELETE", **kwargs)
374312
def help_center_category_update(self, id, data, locale=None, **kwargs):
        ""
        api_path = "/api/v2/help_center/categories/{id}.json"
        api_path = api_path.format(id=id)
        if locale:
            api_opt_path = "/api/v2/help_center/{locale}/categories/{id}.json"
            api_path = api_opt_path.format(id=id, locale=locale)
        return self.call(api_path, method="PUT", data=data, **kwargs)
150193
def update(type, name)
      resource_class = parse_type(type)
      client_setup
      fail_nice 'Must set the hash or json option' unless @options['hash'] || @options['json']
      fail_nice 'Must set the hash OR json option. Not both' if @options['hash'] && @options['json']
      begin
        data = @options['hash'] || JSON.parse(@options['json'])
      rescue JSON::ParserError => e
        fail_nice("Failed to parse json\n#{e.message}")
      end
      matches = resource_class.find_by(@client, name: name)
      fail_nice 'Not Found' if matches.empty?
      resource = matches.first
      begin
        resource.update(data)
        puts 'Updated Successfully!'
      rescue StandardError => e
        fail_nice "Failed to update #{resource.class.name.split('::').last} '#{name}': #{e}"
      end
    end
740614
def update_api_model_schema(restApiId, modelName, schema, region=None, key=None, keyid=None, profile=None):
    '''
    

    '''
    try:
        schema_json = salt.utils.json.dumps(schema) if isinstance(schema, dict) else schema
        conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)
        response = _api_model_patch_replace(conn, restApiId, modelName, '/schema', schema_json)
        return {'updated': True, 'model': _convert_datetime_str(response)}
    except ClientError as e:
        return {'updated': False, 'error': __utils__['boto3.get_error'](e)}
705979
def get_skill_entry(name, skills_data) -> dict:
    
    for e in skills_data.get('skills', []):
        if e.get('name') == name:
            return e
    return {}
580890
def _get_create_update_kwargs(self, value, common_kw):
        
        kw = common_kw.copy()
        kw['body'] = value
        if '_self' in value:
            kw['headers'] = [('Location', value['_self'])]
        return kw
366125
def _update_name(self):
        """"""
        self._name = self._json_state.get('name')
        if not self._name:
            self._name = self.type + ' ' + self.device_id
1047263
protected function doUpdateParts(Skill $model, $data) {
		// remove all relationships before
		SkillPartQuery::create()->filterBySkillRelatedByCompositeId($model)->delete();

		// add them
		$errors = [];
		foreach ($data as $entry) {
			if (!isset($entry['id'])) {
				$errors[] = 'Missing id for Skill';
			} else {
				$related = SkillQuery::create()->findOneById($entry['id']);
				$model->addSkillRelatedByPartId($related);
			}
		}

		if (count($errors) > 0) {
			throw new ErrorsException($errors);
		}
	}
707589
def rename(id, name)
      wf_proxy_id?(id)
      wf_string?(name)
      update(id, name: name)
    end
1356853
def update_milestone(id, **kwargs):
    
    data = update_milestone_raw(id, **kwargs)
    if data:
        return utils.format_json(data)
1308105
def update_name(self):
		

		p = self.api_retrieve()
		p.name = self.name
		p.save()

		self.save()