https://developer.zendesk.com/rest_api/docs/core/groups#delete-group
4183
def group_delete(self, id, **kwargs):
        ""
        api_path = "/api/v2/groups/{id}.json"
        api_path = api_path.format(id=id)
        return self.call(api_path, method="DELETE", **kwargs)
871599
function(groupName, callback) {
        var url = this.getResourceUrl({ path: '/groups/' + groupName, user: null });
        request.del(this.getSignedResourceUrl('DELETE', url), callback);

        return this;
    }
701978
def resource_group_delete(name, **kwargs):
    '''
    

    '''
    result = False
    resconn = __utils__['azurearm.get_client']('resource', **kwargs)
    try:
        group = resconn.resource_groups.delete(name)
        group.wait()
        result = True
    except CloudError as exc:
        __utils__['azurearm.log_cloud_error']('resource', str(exc), **kwargs)

    return result
826821
def delete_group(self, group):
        
        try:
            lgroup = self._get_group(group.name)
            delete(lgroup, database=self._database)
        except ObjectDoesNotExist:
            # it doesn't matter if it doesn't exist
            pass
401842
public function destroy(Group $group)
    {
        $deleted = $this->repository->delete($group);

        return response()->json([
            'error' => !$deleted,
        ]);
    }
1224155
public boolean deleteEntityGroup(EntityGroup entityGroup) {
        String entityGroupName = entityGroup.getName();
        checkEntityGroupIsEmpty(entityGroupName);
        QueryPart<EntityGroup> query = new Query<EntityGroup>("entity-groups")
                .path(entityGroupName, true);
        return httpClientManager.updateMetaData(query, delete());
    }
282036
def delete_by_resource_group_name(resource_group_name, budget_name, custom_headers:nil)
      response = delete_by_resource_group_name_async(resource_group_name, budget_name, custom_headers:custom_headers).value!
      nil
    end
929686
public function deleteGroup (Group $group)
    {
        $this->client->send(
            new Request(
                'POST',
                'https://api.weixin.qq.com/cgi-bin/groups/delete',
                [],
                json_encode([
                    'group' => [
                        'id' => $group->getID(),
                    ],
                ])
            )
        );
    }
236813
function delete_group($group_id)
    {
        $group_cache = $this->_fetch_groups();
        $del_dn      = $group_cache[$group_id]['dn'];

        if (!$this->ldap->delete_entry($del_dn)) {
            $this->set_error(self::ERROR_SAVING, 'errorsaving');
            return false;
        }

        if ($this->cache) {
            unset($group_cache[$group_id]);
            $this->cache->set('groups', $group_cache);
        }

        return true;
    }
245796
def GroupsUsersDelete(self, group_id, user_id):
        
        if self.__SenseApiCall__('/groups/{group_id}/users/{user_id}.json'.format(group_id = group_id, user_id = user_id), 'DELETE'):
            return True
        else:
            self.__error__ = "api call unsuccessful"
            return False
1302564
def delete(options = {})
      options = options.merge(
        group_name: @group_name,
        policy_name: @name
      )
      resp = @client.delete_group_policy(options)
      resp.data
    end
1222035
def delete(self, group_id, nick=None):
        ''''''
        request = TOPRequest('xxxxx.xxxxx.adgroup.delete')
        request['group_id'] = group_id
        if nick!=None: request['nick'] = nick
        self.create(self.execute(request), fields=['success','result','success','result_code','result_message'], models={'result':ADGroup})
        return self.result
4568
public boolean deleteGroup(String groupName) {
		if (groupsFile != null) {
			lock.writeLock().lock();
			try {
				reloadGroupsFromFile();
				groups.remove(groupName);
				return writeGroupFile();
			} finally {
				lock.writeLock().unlock();
			}
		} // end if resourcePath not null
		return false;
	}
983022
def delete_group(group_id, purge_data,**kwargs):
    
    user_id = kwargs.get('user_id')
    try:
        group_i = db.DBSession.query(ResourceGroup).filter(ResourceGroup.id == group_id).one()
    except NoResultFound:
        raise ResourceNotFoundError("Group %s not found"%(group_id))

    group_items = db.DBSession.query(ResourceGroupItem).filter(
                                                    ResourceGroupItem.group_id==group_id).all()
    for gi in group_items:
        db.DBSession.delete(gi)

    if purge_data == 'Y':
        _purge_datasets_unique_to_resource('GROUP', group_id)

    log.info("Deleting group %s, id=%s", group_i.name, group_id)

    group_i.network.check_write_permission(user_id)
    db.DBSession.delete(group_i)
    db.DBSession.flush()
606854
def delete_parameter_group(name, region=None, key=None, keyid=None,
                           profile=None):
    '''
    
    '''
    try:
        conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)
        if not conn:
            return {'results': bool(conn)}

        r = conn.delete_db_parameter_group(DBParameterGroupName=name)
        return {'deleted': bool(r), 'message':
                'Deleted RDS parameter group {0}.'.format(name)}
    except ClientError as e:
        return {'error': __utils__['boto3.get_error'](e)}
247047
def leave_group_users(self, user_id, group_id):
        
        path = {}
        data = {}
        params = {}

        # REQUIRED - PATH - group_id
        """ID"""
        path["group_id"] = group_id

        # REQUIRED - PATH - user_id
        """ID"""
        path["user_id"] = user_id

        self.logger.debug("DELETE /api/v1/groups/{group_id}/users/{user_id} with query params: {params} and form data: {data}".format(params=params, data=data, **path))
        return self.generic_request("DELETE", "/api/v1/groups/{group_id}/users/{user_id}".format(**path), data=data, params=params, no_data=True)
435001
def delete_group(self, group_id):
        

        url = self.TEAM_GROUPS_ID_URL % group_id

        connection = Connection(self.token)
        connection.set_url(self.production, url)

        return connection.delete_request()