@example Request syntax with placeholder values

   db_snapshot.delete()
 @param [Hash] options ({})
 @return [DBSnapshot]
510288
def delete(options = {})
      options = options.merge(db_snapshot_identifier: @snapshot_id)
      resp = @client.delete_db_snapshot(options)
      DBSnapshot.new(
        instance_id: resp.data.db_snapshot.db_instance_identifier,
        snapshot_id: resp.data.db_snapshot.db_snapshot_identifier,
        data: resp.data.db_snapshot,
        client: @client
      )
    end
931525
def delete(options = {})
      options = options.merge(queue_url: @url)
      resp = @client.delete_queue(options)
      resp.data
    end
349973
def delete(path: nil, payload: nil, headers: {}, query: {})
      execute(method: :delete, path: path, headers: headers, query: query, payload: payload)
    end
794397
def delete(options = {})
      options = options.merge(db_cluster_parameter_group_name: @name)
      resp = @client.delete_db_cluster_parameter_group(options)
      resp.data
    end
478031
def delete(options = {})
      options = options.merge(platform_application_arn: @arn)
      resp = @client.delete_platform_application(options)
      resp.data
    end
478290
def update!(**kwords)
      kwords = kwords.map { |k, v| [k.to_s.capitalize, v] }.to_h
      response = @connection.send(:put,
                                  "/snapshots/#{self.Name}",
                                  body: JSON.generate(kwords))
      hash = JSON.parse(response.body, symbolize_names: true)
      return nil if hash == marshal_dump
      marshal_load(hash)
      self
    end
916527
def delete(options = {})
      options = options.merge(bucket: @bucket_name)
      resp = @client.delete_bucket_tagging(options)
      resp.data
    end
238557
def delete(name, skip_final_snapshot=None, final_db_snapshot_identifier=None,
           region=None, key=None, keyid=None, profile=None, tags=None,
           wait_for_deletion=True, timeout=180):
    '''
    
    '''
    if timeout == 180 and not skip_final_snapshot:
        timeout = 420

    if not skip_final_snapshot and not final_db_snapshot_identifier:
        raise SaltInvocationError('At least one of the following must'
                                  ' be specified: skip_final_snapshot'
                                  ' final_db_snapshot_identifier')

    try:
        conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)
        if not conn:
            return {'deleted': bool(conn)}

        kwargs = {}
        if locals()['skip_final_snapshot'] is not None:
            kwargs['SkipFinalSnapshot'] = bool(locals()['skip_final_snapshot'])

        if locals()['final_db_snapshot_identifier'] is not None:
            kwargs['FinalDBSnapshotIdentifier'] = str(locals()['final_db_snapshot_identifier'])  # future lint: disable=blacklisted-function

        res = conn.delete_db_instance(DBInstanceIdentifier=name, **kwargs)

        if not wait_for_deletion:
            return {'deleted': bool(res), 'message':
                    'Deleted RDS instance {0}.'.format(name)}

        start_time = time.time()
        while True:
            res = __salt__['boto_rds.exists'](name=name, tags=tags, region=region,
                                               key=key, keyid=keyid,
                                               profile=profile)
            if not res.get('exists'):
                return {'deleted': bool(res), 'message':
                        'Deleted RDS instance {0} completely.'.format(name)}

            if time.time() - start_time > timeout:
                raise SaltInvocationError('RDS instance {0} has not been '
                                          'deleted completely after {1} '
                                          'seconds'.format(name, timeout))
            log.info('Waiting up to %s seconds for RDS instance %s to be '
                     'deleted.', timeout, name)
            time.sleep(10)
    except ClientError as e:
        return {'error': __utils__['boto3.get_error'](e)}
819338
def delete(options = {})
      options = options.merge(user_name: @name)
      resp = @client.delete_user(options)
      resp.data
    end
1004653
def odba_take_snapshot
			@odba_snapshot_level ||= 0
			snapshot_level = @odba_snapshot_level.next
			current_level = [self]
			tree_level = 0
			while(!current_level.empty?)
				tree_level += 1
				obj_count = 0
				next_level = []
				current_level.each { |item|
					if(item.odba_unsaved?(snapshot_level))
						obj_count += 1
						next_level += item.odba_unsaved_neighbors(snapshot_level)
						item.odba_snapshot(snapshot_level)
					end
				}
				current_level = next_level #.uniq
			end
		end
943264
function _prepSnapshot() {
            var config = this.constructor.config,
                copy = (config.snapshotSerializer || config.serializer).serialize(this);

            // we don't want to store our snapshots in the snapshots because that would make the rollback kind of funny
            // not to mention using more memory for each snapshot.
            delete copy.$$snapshots;

            return copy
        }
1143806
def delete(options = {})
      options = options.merge(saml_provider_arn: @arn)
      resp = @client.delete_saml_provider(options)
      resp.data
    end
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
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
121465
def options_td(record_or_name_or_array, hide_destroy = false)
      items = []
      items << link_to('Edit', edit_polymorphic_path(record_or_name_or_array))
      items << link_to('Delete', polymorphic_path(record_or_name_or_array), :confirm => 'Are you sure?', :method => :delete, :class => "destructive") unless hide_destroy
      list = content_tag(:ul, convert_to_list_items(items))
      content_tag(:td, list, :class => "options")
    end
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
335170
def delete(options = {})
      options = options.merge(launch_configuration_name: @name)
      resp = @client.delete_launch_configuration(options)
      resp.data
    end