@example Request syntax with placeholder values

   db_security_group.delete()
 @param [Hash] options ({})
 @return [EmptyStructure]
359541
def delete(options = {})
      options = options.merge(db_security_group_name: @name)
      resp = @client.delete_db_security_group(options)
      resp.data
    end
1102545
def begin_delete(resource_group_name, policy_name, custom_headers:nil)
      response = begin_delete_async(resource_group_name, policy_name, custom_headers:custom_headers).value!
      nil
    end
1148691
def delete(options = {})
      options = options.merge(db_cluster_snapshot_identifier: @snapshot_id)
      resp = @client.delete_db_cluster_snapshot(options)
      DBClusterSnapshot.new(
        cluster_id: resp.data.db_cluster_snapshot.db_cluster_identifier,
        snapshot_id: resp.data.db_cluster_snapshot.db_cluster_snapshot_identifier,
        data: resp.data.db_cluster_snapshot,
        client: @client
      )
    end
171111
def delete(options = {})
      options = options.merge(topic_arn: @arn)
      resp = @client.delete_topic(options)
      resp.data
    end
1249688
def group_delete(attribs, dir_info)
      attribs = group_record_name_alternatives(attribs)

      check_critical_attribute( attribs, :record_name )

      command = {action: 'delete', scope: 'Groups', attribute: nil, value: nil}
      user_attrs = attribs.merge(command)

      dscl( user_attrs, dir_info )
    end
448480
def delete(options = {})
      options = options.merge(role_name: @name)
      resp = @client.delete_role(options)
      resp.data
    end
1090490
def security_group_rule_delete(auth=None, **kwargs):
    '''
    

    '''
    cloud = get_operator_cloud(auth)
    kwargs = _clean_kwargs(**kwargs)
    return cloud.delete_security_group_rule(**kwargs)
50547
def delete_subscription(subscription, options={})
      raise 'Error: Param subscription is nil!' if subscription.nil?

      url = url_for_resource(subscription)
      begin
        client.delete(url, options) do |response|
          response.code == 200
        end
      rescue => e
        raise e if debug
        false
      end
    end
1369474
def delete
      options = self.class.merge_options()
      response = self.class.delete(self.href, options)
      begin 
        self.class.check_status_code(response)
      rescue
        return false
      end
      return true
    end
1079361
def tick
      deleted = nil
      @to_delete.each do |tuple|
        k = get_key_vals(tuple)
        k_str = MessagePack.pack(k)
        cols_str = @dbm[k_str]
        unless cols_str.nil?
          db_cols = MessagePack.unpack(cols_str)
          delete_cols = val_cols.map{|c| tuple[cols.index(c)]}
          if db_cols == delete_cols
            deleted ||= @dbm.delete k_str
          end
        end
      end
      @to_delete = []

      @invalidated = !deleted.nil?
      unless @pending.empty?
        @delta = @pending
        @pending = {}
      end
      flush
    end
998949
def delete(options = {})
      options = options.merge(
        auto_scaling_group_name: @group_name,
        topic_arn: @topic_arn
      )
      resp = @client.delete_notification_configuration(options)
      resp.data
    end
603878
def delete(options = {})
      options = options.merge(bucket: @bucket_name)
      resp = @client.delete_bucket_lifecycle(options)
      resp.data
    end
931525
def delete(options = {})
      options = options.merge(queue_url: @url)
      resp = @client.delete_queue(options)
      resp.data
    end
216254
def delete_option_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 {'deleted': bool(conn)}

        res = conn.delete_option_group(OptionGroupName=name)
        if not res:
            return {'deleted': bool(res), 'message':
                    'Failed to delete RDS option group {0}.'.format(name)}

        return {'deleted': bool(res), 'message':
                'Deleted RDS option group {0}.'.format(name)}
    except ClientError as e:
        return {'error': __utils__['boto3.get_error'](e)}
132519
def delete(options = {:hard => false})
      if options[:hard]
        self.class.delete(self.id, options)
      else
        return if new_record? or destroyed?
        update_column kakurenbo_column, current_time_from_proper_timezone
      end
    end
982472
def delete(options = {})
      options = options.merge(
        role_name: @role_name,
        policy_name: @name
      )
      resp = @client.delete_role_policy(options)
      resp.data
    end
1338164
def delete(options = {})
      return each({ match: '*', count: 500, max_iterations: 1_000_000, batch_size: 500 }.merge(options)) do |keys|
        @connection.del(*keys)
      end
    end