Delete existing state
        ---
        responseMessages:
            - code: 401
              message: Not authenticated
324947
def delete(self, request, bot_id, id, format=None):
        
        return super(StateDetail, self).delete(request, bot_id, id, format)
370963
def delete(self, request, *args, **kwargs):
        
        #noinspection PyAttributeOutsideInit
        self.object = self.get_object()
        success_url = self.get_success_url()
        meta        = getattr(self.object, '_meta')

        self.object.delete()

        messages.success(
            request,
            _(u'{0} "{1}" deleted.').format(
                meta.verbose_name.lower(),
                str(self.object)
            )
        )

        return redirect(success_url)
665156
def unregisterSds(self, sdsObj):
        
        self.conn.connection._check_login()
        response = self.conn.connection._do_post("{}/{}{}/{}".format(self.conn.connection._api_url, "instances/Sds::", sdsObj.id, 'action/removeSds'))    
        return response
932308
def invalidate_api_key(self, body, params=None):
        
        if body in SKIP_IN_PATH:
            raise ValueError("Empty value passed for a required argument 'body'.")
        return self.transport.perform_request(
            "DELETE", "/_security/api_key", params=params, body=body
        )
848762
def destroy
      authentication = current_user.authentications.find_by(id: params[:id])
      authentication.destroy

      redirect_to authentications_path
    end
233294
def delete_kb
      response = @http.delete(
        "#{BASE_URL}/#{knowledgebase_id}"
      )

      case response.code
      when 204
        nil
      when 400
        raise BadArgumentError, response.parse['error']['message'].join(' ')
      when 401
        raise UnauthorizedError, response.parse['error']['message']
      when 403
        raise ForbiddenError, response.parse['error']['message']
      when 404
        raise NotFoundError, response.parse['error']['message']
      when 409
        raise ConflictError, response.parse['error']['message']
      else
        raise UnknownError, "Oh no! (#{response.code})"
      end
    end
1173710
def delete!(request_options = {})
      res = delete(request_options)
      wait_task(res['taskID'], WAIT_TASK_DEFAULT_TIME_BEFORE_RETRY, request_options)
      res
    end
915509
@DELETE
    @Produces(MediaType.APPLICATION_JSON)
    @Path("/revoke_oauth_access/{appName}")
    @Description("Revokes Oauth access of app from argus for a particular user")
    public Response removeAccess(@Context HttpServletRequest req,@PathParam("appName") String appName) {
        String userName=findUserByToken(req);

        if(appName.equalsIgnoreCase(applicationName))
        {
            authService.deleteByUserId(userName);
            return Response.status(Status.OK).build();
        }
        else
        {
            throw new OAuthException(ResponseCodes.ERR_DELETING_APP, HttpResponseStatus.BAD_REQUEST);
        }

    }
895583
def _delete(self, **kwargs):
        
        requests_params = self._handle_requests_params(kwargs)

        delete_uri = self._meta_data['uri']
        session = self._meta_data['bigip']._meta_data['icr_session']
        response = session.delete(delete_uri, **requests_params)
        if response.status_code == 200 or 201:
            self.__dict__ = {'deleted': True}
921893
def logout
      handler = proc do
        if response.code == 204
          clear_session
        else
          case response.code
          when 401 then
            raise Jiralicious::NotLoggedIn, "Not logged in"
          else
            # Give Net::HTTP reason
            raise Jiralicious::JiraError, response
          end
        end
      end

      request(:delete, "/rest/auth/latest/session", handler: handler)
    end
652075
def delete(options = {})
      options = options.merge(
        policy_arn: @arn,
        version_id: @version_id
      )
      resp = @client.delete_policy_version(options)
      resp.data
    end
829161
public function actionClear()
    {
        OAuth2AuthorizationCode::deleteAll(['<', 'expires', time()]);
        OAuth2RefreshToken::deleteAll(['<', 'expires', time()]);
        OAuth2AccessToken::deleteAll(['<', 'expires', time()]);
    }
510252
def prune_old_authorization_codes():
    

    from .compat import now
    from .models import AuthorizationCode
    
    AuthorizationCode.objects.with_expiration_before(now()).delete()
647005
def delete(self, path, data=None, params=None):
        
        uri = self.config.get_target() + path
        headers = {
            'Authorization': self.config.get_access_token()
            }

        logging.debug("URI=DELETE " + str(uri))
        logging.debug("HEADERS=" + str(headers))

        response = self.session.delete(
            uri, headers=headers, params=params, data=json.dumps(data))

        if response.status_code == 204:
            return response
        else:
            logging.debug("STATUS=" + str(response.status_code))
            logging.debug("CONTENT=" + str(response.content))
            response.raise_for_status()
753256
def auth_remove(name, drop, **kwargs):
    
    ctx = Context(**kwargs)
    ctx.execute_action('auth:group:remove', **{
        'storage': ctx.repo.create_secure_service('storage'),
        'name': name,
        'drop': drop,
    })
781691
def delete(options = {})
      @message.call_api_and_parse_response(:delete, path,
                                           {subscriber_name: name})
    rescue Rest::HttpError => ex
      #if ex.code == 404
      #  Rest.logger.info("Delete got 404, safe to ignore.")
      #  # return ResponseBase as normal
      #  ResponseBase.new({"msg" => "Deleted"}, 404)
      #else
        raise ex
      #end
    end
1081651
def delete(self, token_id, *args, **kwargs):
        

        return self.client._put(
            "{0}/revoked".format(
                self._url(token_id)
            ),
            None,
            *args,
            **kwargs
        )