Deletes an entry..

 @param [Entry|String] entry
 @param [Hash] options
 @return [Boolean]
484212
def delete_entry(entry, options={})
      raise 'Error: Param entry is nil!' if entry.nil?

      url = if entry.is_a?(Resource::Entry)
              url_for_resource(entry)
            elsif entry.is_a?(String)
              url_for_uri(entry)
            else
              raise 'Error: Invalid parameter!'
            end
      begin
        client.delete(url, options) do |response|
          response.code == 200
        end
      rescue => e
        raise e if debug
        false
      end
    end
652075
def delete(options = {})
      options = options.merge(
        policy_arn: @arn,
        version_id: @version_id
      )
      resp = @client.delete_policy_version(options)
      resp.data
    end
97747
def remove_entry(self, entry = None):
        
        
        if entry is None or type(entry) is not v1Entry:
            raise KPError("Need an entry.")
        elif entry in self.entries:
            entry.group.entries.remove(entry)
            self.entries.remove(entry)
            self._num_entries -= 1
            return True
        else:
            raise KPError("Given entry doesn't exist.")
426850
public final boolean remove(E entry) {
        TreeEntry<E> e = getEntry(entry);

        if (e == null) {
            return false;
        } else {
            deleteEntry(e);
        }

        return true;
    }
171111
def delete(options = {})
      options = options.merge(topic_arn: @arn)
      resp = @client.delete_topic(options)
      resp.data
    end
798948
def whitelist_options
      @options[:options] ||= {}.tap do |h|
        h[:verify_card] = @options.fetch(:verify_card, true)
        @options.delete(:verify_card)
        if @options.key?(:verification_merchant_account_id)
          h[:verification_merchant_account_id] = @options.delete(:verification_merchant_account_id)
        end
      end
      super
    end
82049
def delete(options = {})
      options = options.merge(user_name: @user_name)
      resp = @client.delete_login_profile(options)
      resp.data
    end
1317809
def delete(options = {})
      options = options.merge(layer_id: @id)
      resp = @client.delete_layer(options)
      resp.data
    end
566550
def delete(options = {})
      options = options.merge(stack_id: @id)
      resp = @client.delete_stack(options)
      resp.data
    end
1076568
def delete_link(*args)
      options = {:method => :delete, :confirm => "Are you sure you want to delete this?"}.merge(extract_options_from_args!(args)||{})
      args << options
      link_to(*args)
    end
147173
def delete(options = {})
      options = options.merge(
        auto_scaling_group_name: @group_name,
        lifecycle_hook_name: @name
      )
      resp = @client.delete_lifecycle_hook(options)
      resp.data
    end
846215
def delete(options = {})
      options = options.merge(db_parameter_group_name: @name)
      resp = @client.delete_db_parameter_group(options)
      resp.data
    end
502440
def delete_at(index)
      if index < 0
        index = @entry_counter + index
      end

      return nil if index < 0 || index >= @entry_counter

      deleted_value = nil
      @store.transaction do
        deleted_value = @root.delete_at(index)
        self.entry_counter -= 1

        # Eliminate single entry nodes at the top.
        while !@root.is_leaf? && @root.size == 1
          @root = @root.children.first
          @root.parent = nil
        end
      end

      deleted_value
    end
1031824
def remove_entry(self, entry):
        
        if not isinstance(entry, Entry):
            raise TypeError("entry param must be of type Entry.")
        if not entry in self.entries:
            raise ValueError("Entry doesn't exist / not bound to this datbase.")
        
        entry.group.entries.remove(entry)
        self.entries.remove(entry)
1188135
def delete(key, options = {})
      return super if options.include?(:raw)
      value, expires = super
      value if !expires || Time.now <= Time.at(expires)
    end
1244064
def delete(attribute, type = nil, **options)
      attribute, type, options = normalize_arguments(attribute, type, options)
      matches = where(attribute, type, options)
      matches.each do |error|
        @errors.delete(error)
      end
      matches.map(&:message)
    end
864556
def delete(options = {})
      options = options.merge(subscription_name: @name)
      resp = @client.delete_event_subscription(options)
      EventSubscription.new(
        name: resp.data.event_subscription.cust_subscription_id,
        data: resp.data.event_subscription,
        client: @client
      )
    end