Use this API to delete policymap resources of given names.
341315
public static base_responses delete(nitro_service client, String mappolicyname[]) throws Exception {
		base_responses result = null;
		if (mappolicyname != null && mappolicyname.length > 0) {
			policymap deleteresources[] = new policymap[mappolicyname.length];
			for (int i=0;i<mappolicyname.length;i++){
				deleteresources[i] = new policymap();
				deleteresources[i].mappolicyname = mappolicyname[i];
			}
			result = delete_bulk_request(client, deleteresources);
		}
		return result;
	}
308622
def remove(client, names):
    """"""
    from renku.models.refs import LinkReference
    datasets = {name: client.dataset_path(name) for name in names}

    if not datasets:
        raise click.BadParameter(
            'use dataset name or identifier', param_hint='names'
        )

    unknown = [
        name
        for name, path in datasets.items() if not path or not path.exists()
    ]
    if unknown:
        raise click.BadParameter(
            'unknown datasets ' + ', '.join(unknown), param_hint='names'
        )

    datasets = set(datasets.values())

    with progressbar(
        datasets,
        label='Removing metadata files'.ljust(30),
        item_show_func=lambda item: str(item) if item else '',
    ) as bar:
        for dataset in bar:
            if dataset and dataset.exists():
                dataset.unlink()

    with progressbar(
        list(LinkReference.iter_items(client, common_path='datasets')),
        label='Removing aliases'.ljust(30),
        item_show_func=lambda item: item.name if item else '',
    ) as bar:
        for ref in bar:
            if ref.reference in datasets:
                ref.delete()

    click.secho('OK', fg='green')
1347174
def delete_service_bindings(self, service_name):
        
        instance = self.get_instance(service_name)
        return self.api.delete(instance['service_bindings_url'])
795252
public static base_response delete(nitro_service client, dnsnameserver resource) throws Exception {
		dnsnameserver deleteresource = new dnsnameserver();
		deleteresource.ip = resource.ip;
		deleteresource.dnsvservername = resource.dnsvservername;
		return deleteresource.delete_resource(client);
	}
368323
public void deleteRelationsFromResource(String resourceName, CmsRelationFilter filter) throws CmsException {

        CmsResource resource = readResource(resourceName, CmsResourceFilter.ALL);
        m_securityManager.deleteRelationsForResource(m_context, resource, filter);
    }
1369094
public OperationFuture<List<AlertPolicy>> delete(AlertPolicy... policyRefs) {
        List<AlertPolicy> policiesList = Arrays.asList(policyRefs);

        List<JobFuture> jobs = policiesList.stream()
            .map(ref -> delete(ref).jobFuture())
            .collect(toList());

        return new OperationFuture<>(
            policiesList,
            new ParallelJobsFuture(jobs)
        );
    }
1253355
private void deleteFromIndices(ApiType oldObj, String key) {
    for (Map.Entry<String, Function<ApiType, List<String>>> indexEntry : this.indexers.entrySet()) {
      Function<ApiType, List<String>> indexFunc = indexEntry.getValue();
      List<String> indexValues = indexFunc.apply(oldObj);
      if (io.kubernetes.client.util.common.Collections.isEmptyCollection(indexValues)) {
        continue;
      }

      Map<String, Set<String>> index = this.indices.get(indexEntry.getKey());
      if (index == null) {
        continue;
      }
      for (String indexValue : indexValues) {
        Set<String> indexSet = index.get(indexValue);
        if (indexSet != null) {
          indexSet.remove(key);
        }
      }
    }
  }
737681
public static base_response delete(nitro_service client, String urlname) throws Exception {
		vpnurl deleteresource = new vpnurl();
		deleteresource.urlname = urlname;
		return deleteresource.delete_resource(client);
	}
190366
private void removeResourceMethods(Object theProvider, Class<?> clazz, Collection<String> resourceNames) throws ConfigurationException {
		for (Method m : ReflectionUtil.getDeclaredMethods(clazz)) {
			BaseMethodBinding<?> foundMethodBinding = BaseMethodBinding.bindMethod(m, getFhirContext(), theProvider);
			if (foundMethodBinding == null) {
				continue; // not a bound method
			}
			if (foundMethodBinding instanceof ConformanceMethodBinding) {
				myServerConformanceMethod = null;
				continue;
			}
			String resourceName = foundMethodBinding.getResourceName();
			if (!resourceNames.contains(resourceName)) {
				resourceNames.add(resourceName);
			}
		}
	}
1055561
@Override
    public boolean deletePolicy(String name) throws PolicyStoreException {
        String pid = this.getPID(name);
        if (!contains(name)) {
            throw new PolicyStoreException("Delete: object " + pid
                                                 + " not found.");
        }
        try {
            this.apiMService.modifyObject(getContext(),
                                          pid,
                                          "D",
                                          null,
                                          null,
                                          "Deleting policy " + pid,
                                          null);
        } catch (ServerException e) {
            throw new PolicyStoreException("Delete: error deleting policy "
                                                 + pid
                                                 + " - "
                                                 + e.getMessage(),
                                                 e);
        }

        return true;
    }
819933
def delete_source_map(srcmap_file, names, logger=None):
    
    with fits.open(srcmap_file) as hdulist:
        hdunames = [hdu.name.upper() for hdu in hdulist]

        if not isinstance(names, list):
            names = [names]

        for name in names:
            if not name.upper() in hdunames:
                continue
            del hdulist[name.upper()]

        hdulist.writeto(srcmap_file, overwrite=True)
752228
void removeResourceModels(final Bundle bundle) {
        this.logger.info("Removing resource models of bundle " + displayNameOf(bundle) + "...");
        MatchedBundlesPredicate sourcesWithBundles = new MatchedBundlesPredicate(bundle);
        for (Collection<OsgiModelSource<?>> values : this.typeNameToModelSourcesMap.values()) {
            CollectionUtils.filter(values, sourcesWithBundles);
        }
        clearLookupCaches();
        this.logger.info("Removed " + sourcesWithBundles.getFilteredElements()
                + " resource models of bundle " + displayNameOf(bundle) + "...");
    }
1028263
def delete(resource_group_name, policy_name, custom_headers:nil)
      response = delete_async(resource_group_name, policy_name, custom_headers:custom_headers).value!
      nil
    end
708784
def delete_service(resource_root, name, cluster_name="default"):
  
  return call(resource_root.delete,
      "%s/%s" % (SERVICES_PATH % (cluster_name,), name),
      ApiService)
835844
public static void destroyAll() {
        for (Map.Entry<ServerConfig, ProtocolConfig> entry : SERVER_MAP.entrySet()) {
            entry.getValue().destory();
        }
        try {
            ProtocolConfig.destroyAll();
        } catch (Exception e) {
            // NOPMD
        }
    }
1345603
def delete_role(self, name):
        # type: (str) -> None
        """"""
        client = self._client('iam')
        inline_policies = client.list_role_policies(
            RoleName=name
        )['PolicyNames']
        for policy_name in inline_policies:
            self.delete_role_policy(name, policy_name)
        client.delete_role(RoleName=name)
180432
public void delete(String name) throws IOException {
        if (name.equalsIgnoreCase(MAP)) {
            maps = null;
        } else {
          throw new IOException("Attribute name not recognized by " +
                        "CertAttrSet:PolicyMappingsExtension.");
        }
        encodeThis();
    }