DeleteServiceDefinition.
        [Preview API]
        :param str service_type:
        :param str identifier:
545598
def delete_service_definition(self, service_type, identifier):
        
        route_values = {}
        if service_type is not None:
            route_values['serviceType'] = self._serialize.url('service_type', service_type, 'str')
        if identifier is not None:
            route_values['identifier'] = self._serialize.url('identifier', identifier, 'str')
        self._send(http_method='DELETE',
                   location_id='d810a47d-f4f4-4a62-a03f-fa1860585c4c',
                   version='5.0-preview.1',
                   route_values=route_values)
646757
def delete_resource(self, session, data, api_type, obj_id):
        
        resource = self._fetch_resource(session, api_type, obj_id,
                                        Permissions.VIEW)
        self._check_instance_relationships_for_delete(resource)

        session.delete(resource)
        session.commit()

        response = JSONAPIResponse()
        response.status_code = 204

        return response
603076
public void deleteAllPresentationModelsOfType(String presentationModelType) {
        getClientConnector().send(new DeletedAllPresentationModelsOfTypeNotification(presentationModelType));
        List<ClientPresentationModel> models = new LinkedList<ClientPresentationModel>(findAllPresentationModelsByType(presentationModelType));
        for (ClientPresentationModel model: models) {
            delete(model, false);
        }
    }
97261
def file_remove_types(object_id, input_params={}, always_retry=True, **kwargs):
    
    return DXHTTPRequest('/%s/removeTypes' % object_id, input_params, always_retry=always_retry, **kwargs)
375338
def endpoint_delete(endpoint_id):
    
    client = get_client()
    res = client.delete_endpoint(endpoint_id)
    formatted_print(res, text_format=FORMAT_TEXT_RAW, response_key="message")
17579
def find_service_by_type(self, service_type):
        
        for service in self._services:
            if service_type == service.type:
                return service
        return None
402542
def delete(self, service_name, *ids, **kwargs):
        """"""
        return self._send(requests.delete, service_name, id=ids, **kwargs)
1318810
public void deleteService(String id, boolean force) {
        try {
            if (id == null || id.isEmpty()) {
                id = selectRunningService();
            }
            final String idFinal = id;
            int input = 'Y';
            if (!force) {
                OutputStreamFormater.printValue(String.format(
                    "Do you really want to delete the connector: %s (Y/n): ", id));
                input = keyboard.read();
            }
            if ('n' != (char) input && 'N' != (char) input) {
                SecurityContext.executeWithSystemPermissions(new Callable<Object>() {
                    @Override
                    public Object call() throws Exception {
                        serviceManager.delete(idFinal);
                        return null;
                    }
                });
                OutputStreamFormater.printValue(String.format("Service: %s successfully deleted", id));
            }
        } catch (ExecutionException e) {
            e.printStackTrace();
            System.err.println("Could not delete service");
        } catch (IOException e) {
            e.printStackTrace();
            System.err.println("Unexpected Error");
        }
    }
468342
def remove_description_by_type(self, type_p):
        
        if not isinstance(type_p, VirtualSystemDescriptionType):
            raise TypeError("type_p can only be an instance of type VirtualSystemDescriptionType")
        self._call("removeDescriptionByType",
                     in_p=[type_p])
135744
def remove(self, identifier: Union[DataObjectReplica, int]):
        
        if isinstance(identifier, int):
            self._remove_by_number(identifier)
        elif isinstance(identifier, DataObjectReplica):
            self._remove_by_object(identifier)
        else:
            raise TypeError("Can only remove by number or by object reference: `%s` given" % type(identifier))
962989
def DeleteMetricDescriptor(self, request, context):
        
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")
191008
@Override
    public void unregisterService(ServiceInstance<T> service) throws Exception
    {
        Entry<T> entry = services.remove(service.getId());
        internalUnregisterService(entry);
    }
897794
def delete
      response = service.send(:"#{delete_method_prefix}_delete", {:"#{ac_obj_type}_id" => self.id})
      response.at_xpath('//status').attr('code') == 'ok'
    end
904766
async def delete(self, service_id: str) -> bool:
        

        await self.docker._query(
            "services/{service_id}".format(service_id=service_id), method="DELETE"
        )
        return True
315671
def _offload_service_containers(self, service):
        
        if not isinstance(service, Service):
            raise TypeError("service must be an instance of Service")

        if service.containers:
            for key in list(service.containers.keys()):
                if key in service.containers:
                    del service.containers[key]
202083
@Override
    public String delete(EntityDeleteOperation deleter) throws ServiceException {
        try {
            return service.delete(deleter);
        } catch (UniformInterfaceException e) {
            throw processCatch(new ServiceException(e));
        } catch (ClientHandlerException e) {
            throw processCatch(new ServiceException(e));
        }
    }
1362403
public void unregisterTaskDef(String taskType) {
        Preconditions.checkArgument(StringUtils.isNotBlank(taskType), "Task type cannot be blank");
        stub.deleteTask(MetadataServicePb.DeleteTaskRequest.newBuilder()
                .setTaskType(taskType)
                .build()
        );
    }