Module: Elastic::EnterpriseSearch::AppSearch::Actions

Included in:: Client

Defined in:: lib/elastic/app-search/api/engine.rb,
lib/elastic/app-search/api/schema.rb,
lib/elastic/app-search/api/search.rb,
lib/elastic/app-search/api/api_key.rb,
lib/elastic/app-search/api/api_logs.rb,
lib/elastic/app-search/api/curation.rb,
lib/elastic/app-search/api/documents.rb,
lib/elastic/app-search/api/put_schema.rb,
lib/elastic/app-search/api/denied_urls.rb,
lib/elastic/app-search/api/put_api_key.rb,
lib/elastic/app-search/api/synonym_set.rb,
lib/elastic/app-search/api/list_engines.rb,
lib/elastic/app-search/api/multi_search.rb,
lib/elastic/app-search/api/put_curation.rb,
lib/elastic/app-search/api/create_engine.rb,
lib/elastic/app-search/api/delete_engine.rb,
lib/elastic/app-search/api/list_api_keys.rb,
lib/elastic/app-search/api/put_documents.rb,
lib/elastic/app-search/api/crawler_domain.rb,
lib/elastic/app-search/api/create_api_key.rb,
lib/elastic/app-search/api/delete_api_key.rb,
lib/elastic/app-search/api/list_curations.rb,
lib/elastic/app-search/api/list_documents.rb,
lib/elastic/app-search/api/search_explain.rb,
lib/elastic/app-search/api/count_analytics.rb,
lib/elastic/app-search/api/crawler_metrics.rb,
lib/elastic/app-search/api/create_curation.rb,
lib/elastic/app-search/api/delete_curation.rb,
lib/elastic/app-search/api/index_documents.rb,
lib/elastic/app-search/api/put_synonym_set.rb,
lib/elastic/app-search/api/search_settings.rb,
lib/elastic/app-search/api/crawler_overview.rb,
lib/elastic/app-search/api/delete_documents.rb,
lib/elastic/app-search/api/log_clickthrough.rb,
lib/elastic/app-search/api/query_suggestion.rb,
lib/elastic/app-search/api/search_es_search.rb,
lib/elastic/app-search/api/list_synonym_sets.rb,
lib/elastic/app-search/api/crawler_user_agent.rb,
lib/elastic/app-search/api/create_synonym_set.rb,
lib/elastic/app-search/api/delete_synonym_set.rb,
lib/elastic/app-search/api/put_crawler_domain.rb,
lib/elastic/app-search/api/put_crawler_sitemap.rb,
lib/elastic/app-search/api/put_search_settings.rb,
lib/elastic/app-search/api/list_crawler_domains.rb,
lib/elastic/app-search/api/top_clicks_analytics.rb,
lib/elastic/app-search/api/crawler_crawl_request.rb,
lib/elastic/app-search/api/crawler_process_crawl.rb,
lib/elastic/app-search/api/create_crawler_domain.rb,
lib/elastic/app-search/api/delete_crawler_domain.rb,
lib/elastic/app-search/api/reset_search_settings.rb,
lib/elastic/app-search/api/top_queries_analytics.rb,
lib/elastic/app-search/api/add_meta_engine_source.rb,
lib/elastic/app-search/api/crawler_crawl_schedule.rb,
lib/elastic/app-search/api/create_crawler_sitemap.rb,
lib/elastic/app-search/api/delete_crawler_sitemap.rb,
lib/elastic/app-search/api/put_crawler_crawl_rule.rb,
lib/elastic/app-search/api/put_crawler_entry_point.rb,
lib/elastic/app-search/api/create_crawler_crawl_rule.rb,
lib/elastic/app-search/api/delete_crawler_crawl_rule.rb,
lib/elastic/app-search/api/delete_meta_engine_source.rb,
lib/elastic/app-search/api/crawler_url_tracing_result.rb,
lib/elastic/app-search/api/create_crawler_entry_point.rb,
lib/elastic/app-search/api/delete_crawler_entry_point.rb,
lib/elastic/app-search/api/put_crawler_crawl_schedule.rb,
lib/elastic/app-search/api/adaptive_relevance_settings.rb,
lib/elastic/app-search/api/delete_active_crawl_request.rb,
lib/elastic/app-search/api/list_crawler_crawl_requests.rb,
lib/elastic/app-search/api/list_crawler_process_crawls.rb,
lib/elastic/app-search/api/crawler_active_crawl_request.rb,
lib/elastic/app-search/api/create_crawler_crawl_request.rb,
lib/elastic/app-search/api/create_crawler_process_crawl.rb,
lib/elastic/app-search/api/crawler_url_extraction_result.rb,
lib/elastic/app-search/api/crawler_url_validation_result.rb,
lib/elastic/app-search/api/delete_crawler_crawl_schedule.rb,
lib/elastic/app-search/api/adaptive_relevance_suggestions.rb,
lib/elastic/app-search/api/put_adaptive_relevance_settings.rb,
lib/elastic/app-search/api/crawler_domain_validation_result.rb,
lib/elastic/app-search/api/crawler_process_crawl_denied_urls.rb,
lib/elastic/app-search/api/put_adaptive_relevance_suggestions.rb,
lib/elastic/app-search/api/delete_crawler_active_crawl_request.rb,
lib/elastic/app-search/api/list_adaptive_relevance_suggestions.rb,
lib/elastic/app-search/api/refresh_adaptive_relevance_update_process.rb

Instance Method Summary collapse

#adaptive_relevance_settings(engine_name, arguments = {}) ⇒ Object

AdaptiveRelevanceSettings - Retrieve adaptive relevance settings Retrieve adaptive relevance settings.
#adaptive_relevance_suggestions(engine_name, arguments = {}) ⇒ Object

AdaptiveRelevanceSuggestions - Retrieve adaptive relevance Retrieve adaptive relevance for a single query.
#add_meta_engine_source(engine_name, arguments = {}) ⇒ Object

Engines - Add a source engine Adds a source engine to a given meta engine.
#api_key(arguments = {}) ⇒ Object

Credentials - Retrieve an API key Retrieves details of an API key.
#api_logs(engine_name, arguments = {}) ⇒ Object

APILogs - Retrieve API logs The API Log displays API request and response data at the Engine level.
#count_analytics(engine_name, arguments = {}) ⇒ Object

Analytics - Query for analytics counts data Returns the number of clicks and total number of queries over a period.
#crawler_active_crawl_request(engine_name, arguments = {}) ⇒ Object

Crawler - Get active crawl request details Returns active crawl request details.
#crawler_crawl_request(engine_name, arguments = {}) ⇒ Object

Crawler - Get crawl request details Returns crawl request details.
#crawler_crawl_schedule(engine_name, arguments = {}) ⇒ Object

Crawler - Get crawl schedule Returns the current crawl schedule for a given engine.
#crawler_domain(engine_name, arguments = {}) ⇒ Object

Crawler - Get domain configuration Returns crawler domain configuration details.
#crawler_domain_validation_result(arguments = {}) ⇒ Object

Crawler - Validate Domain with Crawler Performs a number of checks on a given domain name to make sure it is ready to be crawled and ingested into App Search.
#crawler_metrics(arguments = {}) ⇒ Object

Crawler - Retrieve a snapshot of crawler metrics Retrieves a momentary snapshot of key crawler metrics, including global and node-level crawler health.
#crawler_overview(engine_name, arguments = {}) ⇒ Object

Crawler - Retrieve crawler configuration overview Retrieves crawler configuration overview of a given engine, including configured domains.
#crawler_process_crawl(engine_name, arguments = {}) ⇒ Object

Crawler - Get process crawl details Returns process crawl details.
#crawler_process_crawl_denied_urls(engine_name, arguments = {}) ⇒ Object

Crawler - View denied urls for Process Crawl Provides a sample list of urls identified for deletion by the given process crawl id.
#crawler_url_extraction_result(engine_name, arguments = {}) ⇒ Object

Crawler - Extract content from a URL Performs an HTTP request to a given URL and extracts content from the page using standard App Search Crawler extraction pipeline.
#crawler_url_tracing_result(engine_name, arguments = {}) ⇒ Object

Crawler - Trace a history of a crawled URL Returns information about the history of a given URL with the App Search Crawler.
#crawler_url_validation_result(engine_name, arguments = {}) ⇒ Object

Crawler - Validate URL with Crawler Performs a number of checks on a given URL to make sure it is ready to be crawled and ingested into App Search.
#crawler_user_agent(arguments = {}) ⇒ Object

Crawler - Get the User-Agent header value for the crawler Retrieves the currently configured value for the User-Agent header used for all Crawler HTTP requests.
#create_api_key(arguments = {}) ⇒ Object

Credentials - Create an API key Creates an App Search API key.
#create_crawler_crawl_request(engine_name, arguments = {}) ⇒ Object

Crawler - Create a crawl request Creates a request to perform a crawl of a given engine with the Crawler.
#create_crawler_crawl_rule(engine_name, arguments = {}) ⇒ Object

Crawler - Create a crawl rule Creates a crawl rule for a given engine and domain.
#create_crawler_domain(engine_name, arguments = {}) ⇒ Object

Crawler - Create a crawler domain Creates a crawler domain configuration for a given engine.
#create_crawler_entry_point(engine_name, arguments = {}) ⇒ Object

Crawler - Create a crawler entry point Creates a crawler domain entry point for a given engine and domain.
#create_crawler_process_crawl(engine_name, arguments = {}) ⇒ Object

Crawler - Create a process crawl Queues a task to reprocess crawled documents with current crawl configuration.
#create_crawler_sitemap(engine_name, arguments = {}) ⇒ Object

Crawler - Create a crawler sitemap Creates a crawler sitemap configuration for a given engine and domain.
#create_curation(engine_name, arguments = {}) ⇒ Object

Curations - Create a new curation Create a new curation for the engine.
#create_engine(arguments = {}) ⇒ Object

Engines - Create an Engine Creates an App Search Engine.
#create_synonym_set(engine_name, arguments = {}) ⇒ Object

Synonyms - Create a synonym set Creates a new synonym set for the engine.
#curation(engine_name, arguments = {}) ⇒ Object

Curations - Retrieve a curation Retrieves a curation by ID.
#delete_active_crawl_request(engine_name, arguments = {}) ⇒ Object

Crawler - Cancel an active crawl request Cancels an active crawl request, stopping a running crawl if needed.
#delete_api_key(arguments = {}) ⇒ Object

Credentials - Delete an API key Deletes a given API key.
#delete_crawler_active_crawl_request(engine_name, arguments = {}) ⇒ Object

Crawler - Cancel an active crawl request Cancels an active crawl request, stopping a running crawl if needed.
#delete_crawler_crawl_rule(engine_name, arguments = {}) ⇒ Object

Crawler - Delete a crawl rule Deletes a crawl rule from a given domain.
#delete_crawler_crawl_schedule(engine_name, arguments = {}) ⇒ Object

Crawler - Delete a crawl schedule Deletes a crawl schedule for a given engine.
#delete_crawler_domain(engine_name, arguments = {}) ⇒ Object

Crawler - Delete domain configuration Deletes crawler domain configuration for a given domain.
#delete_crawler_entry_point(engine_name, arguments = {}) ⇒ Object

Crawler - Delete an entry point Deletes a crawler entry point.
#delete_crawler_sitemap(engine_name, arguments = {}) ⇒ Object

Crawler - Delete a sitemap Deletes a sitemap from a given domain.
#delete_curation(engine_name, arguments = {}) ⇒ Object

Curations - Delete a curation Deletes a curation set by ID.
#delete_documents(engine_name, arguments = {}) ⇒ Object

Documents - Delete documents by ID Deletes documents for given Document IDs.
#delete_engine(engine_name, arguments = {}) ⇒ Object

Engines - Delete an Engine Delete an engine by name.
#delete_meta_engine_source(engine_name, arguments = {}) ⇒ Object

Engines - Delete a source engine Deletes a source engine from a given meta engine.
#delete_synonym_set(engine_name, arguments = {}) ⇒ Object

Synonyms - Delete a synonym set Deletes a synonym set by ID.
#denied_urls(engine_name, arguments = {}) ⇒ Object

Crawler - View denied urls for Process Crawl Provides a sample list of urls identified for deletion by the given process crawl id.
#documents(engine_name, arguments = {}) ⇒ Object

Documents - Retrieve one or more documents Retrieves one or more documents by id.
#engine(engine_name, arguments = {}) ⇒ Object

Engines - Retrieve an engine Retrieves details of a given engine by its name.
#index_documents(engine_name, arguments = {}) ⇒ Object

Documents - Create a new document Create or update documents.
#list_adaptive_relevance_suggestions(engine_name, arguments = {}) ⇒ Object

AdaptiveRelevanceSuggestions - Retrieve adaptive relevance Retrieve adaptive relevance.
#list_api_keys(arguments = {}) ⇒ Object

Credentials - Retrieve all API keys List the details of all API keys.
#list_crawler_crawl_requests(engine_name, arguments = {}) ⇒ Object

Crawler - List crawl requests Returns a list of latest crawl requests for a given engine.
#list_crawler_domains(engine_name, arguments = {}) ⇒ Object

Crawler - List crawler domains Returns a list of crawler domains.
#list_crawler_process_crawls(engine_name, arguments = {}) ⇒ Object

Crawler - List process crawls Returns a list of latest process crawls for a given engine.
#list_curations(engine_name, arguments = {}) ⇒ Object

Curations - Retrieve all curations Retrieve available curations for the given engine.
#list_documents(engine_name, arguments = {}) ⇒ Object

Documents - Retrieve all documents Lists up to 10,000 documents.
#list_engines(arguments = {}) ⇒ Object

Engines - Retrieve all engines Retrieves all engines with optional pagination support.
#list_synonym_sets(engine_name, arguments = {}) ⇒ Object

Synonyms - Retrieve all synonym sets Retrieves all available synonym sets for the engine.
#log_clickthrough(engine_name, arguments = {}) ⇒ Object

Click - Tracks results that were clicked after a query Tracks results that were clicked after a query.
#multi_search(engine_name, arguments = {}) ⇒ Object

MultiSearch - Submit a multi search Submit a multi search query and receive a set of results with meta data.
#put_adaptive_relevance_settings(engine_name, arguments = {}) ⇒ Object

AdaptiveRelevanceSettings - Update adaptive relevance settings Update adaptive relevance settings.
#put_adaptive_relevance_suggestions(engine_name, arguments = {}) ⇒ Object

AdaptiveRelevanceSuggestions - Update adaptive relevance Update adaptive relevance.
#put_api_key(arguments = {}) ⇒ Object

Credentials - Update an API key Updates an API key.
#put_crawler_crawl_rule(engine_name, arguments = {}) ⇒ Object

Crawler - Update a crawl rule Updates crawl rule configuration.
#put_crawler_crawl_schedule(engine_name, arguments = {}) ⇒ Object

Crawler - Set crawl schedule Sets up a crawl schedule for a given engine.
#put_crawler_domain(engine_name, arguments = {}) ⇒ Object

Crawler - Update domain configuration Updates crawler domain configuration for a given domain.
#put_crawler_entry_point(engine_name, arguments = {}) ⇒ Object

Crawler - Update a crawler entry point Updates a crawler entry point with a new value.
#put_crawler_sitemap(engine_name, arguments = {}) ⇒ Object

Crawler - Update a sitemap Updates sitemap configuration.
#put_curation(engine_name, arguments = {}) ⇒ Object

Curations - Update a curation Updates an existing curation.
#put_documents(engine_name, arguments = {}) ⇒ Object

Documents - Partial update of documents Update specific document fields by id and field.
#put_schema(engine_name, arguments = {}) ⇒ Object

Schema - Update engine schema Update schema for the current engine.
#put_search_settings(engine_name, arguments = {}) ⇒ Object

Synonyms - Update search settings Updates search settings for the engine.
#put_synonym_set(engine_name, arguments = {}) ⇒ Object

Synonyms - Update a synonym set Updates a synonym set by ID.
#query_suggestion(engine_name, arguments = {}) ⇒ Object

QuerySuggestion - Retrieve query suggestions Provide relevant query suggestions for incomplete queries.
#refresh_adaptive_relevance_update_process(engine_name, arguments = {}) ⇒ Object

AdaptiveRelevanceSettings - Retrieve adaptive relevance settings Update suggestions process refresh.
#reset_search_settings(engine_name, arguments = {}) ⇒ Object

Synonyms - Reset search settings Resets search settings for the engine.
#schema(engine_name, arguments = {}) ⇒ Object

Schema - Retrieve engine schema Retrieve current schema for the engine.
#search(engine_name, arguments = {}) ⇒ Object

Search - Submit a search Submit a search and receive a set of results with meta data.
#search_es_search(engine_name, arguments = {}) ⇒ Object

ElasticsearchSearch - Run a search Execute the provided Elasticsearch search query against an App Search Engine.
#search_explain(engine_name, arguments = {}) ⇒ Object

SearchExplain - Retrieve the search query Submit a search and retrieve an Elasticsearch query.
#search_settings(engine_name, arguments = {}) ⇒ Object

SearchSettings - Retrieve search settings Retrieve current search settings for the engine.
#synonym_set(engine_name, arguments = {}) ⇒ Object

Synonyms - Retrieve a synonym set Retrieves a synonym set by ID.
#top_clicks_analytics(engine_name, arguments = {}) ⇒ Object

Analytics - Query for analytics click data Returns the number of clicks received by a document in descending order.
#top_queries_analytics(engine_name, arguments = {}) ⇒ Object

Analytics - Query for analytics query data Returns queries analytics by usage count.

Instance Method Details

#adaptive_relevance_settings(engine_name, arguments = {}) ⇒ `Object`

AdaptiveRelevanceSettings - Retrieve adaptive relevance settings Retrieve adaptive relevance settings

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments

Options Hash (arguments):

:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/adaptive-relevance-api-reference.html#adaptive-relevance-api-get-engine-adaptive-relevance-settings

# File 'lib/elastic/app-search/api/adaptive_relevance_settings.rb', line 33

def adaptive_relevance_settings(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name

  headers = arguments.delete(:headers) || {}
  request(
    :get,
    "api/as/v0/engines/#{engine_name}/adaptive_relevance/settings/",
    arguments,
    nil,
    headers
  )
end

#adaptive_relevance_suggestions(engine_name, arguments = {}) ⇒ `Object`

AdaptiveRelevanceSuggestions - Retrieve adaptive relevance Retrieve adaptive relevance for a single query

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments
body (Hash) —

a customizable set of options

Options Hash (arguments):

:search_suggestion_query (String) —

Query to obtain suggestions (Required)
:body (Hash)
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/adaptive-relevance-api-reference.html#adaptive-relevance-api-get-engine-adaptive-relevance-suggestions-query

# File 'lib/elastic/app-search/api/adaptive_relevance_suggestions.rb', line 37

def adaptive_relevance_suggestions(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name

  unless arguments[:search_suggestion_query]
    raise ArgumentError,
          "Required parameter 'search_suggestion_query' missing"
  end

  search_suggestion_query = arguments.delete(:search_suggestion_query)
  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}
  request(
    :post,
    "api/as/v0/engines/#{engine_name}/adaptive_relevance/suggestions/#{search_suggestion_query}/",
    arguments,
    body,
    headers
  )
end

#add_meta_engine_source(engine_name, arguments = {}) ⇒ `Object`

Engines - Add a source engine Adds a source engine to a given meta engine

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments

Options Hash (arguments):

:source_engines (Array<String>)
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/meta-engines.html#meta-engines-add-source-engines

# File 'lib/elastic/app-search/api/add_meta_engine_source.rb', line 34

def add_meta_engine_source(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name

  source_engines = arguments.delete(:source_engines) || {}
  headers = arguments.delete(:headers) || {}
  request(
    :post,
    "api/as/v1/engines/#{engine_name}/source_engines/",
    arguments,
    source_engines,
    headers
  )
end

#api_key(arguments = {}) ⇒ `Object`

Credentials - Retrieve an API key Retrieves details of an API key

Parameters:

arguments (Hash) (defaults to: {}) —

endpoint arguments

Options Hash (arguments):

:api_key_name (String) —

Name of an API key (Required)
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/credentials.html#credentials-single

# File 'lib/elastic/app-search/api/api_key.rb', line 33

def api_key(arguments = {})
  raise ArgumentError, "Required parameter 'api_key_name' missing" unless arguments[:api_key_name]

  api_key_name = arguments.delete(:api_key_name)
  headers = arguments.delete(:headers) || {}
  request(
    :get,
    "api/as/v1/credentials/#{api_key_name}/",
    arguments,
    nil,
    headers
  )
end

#api_logs(engine_name, arguments = {}) ⇒ `Object`

APILogs - Retrieve API logs The API Log displays API request and response data at the Engine level

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments
body (Hash) —

a customizable set of options

Options Hash (arguments):

:body (Hash) — default: Required: filters
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/api-logs.html

# File 'lib/elastic/app-search/api/api_logs.rb', line 38

def api_logs(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name
  raise ArgumentError, "Required parameter 'body (filters)' missing" unless arguments[:body]

  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}
  request(
    :post,
    "api/as/v1/engines/#{engine_name}/logs/api/",
    arguments,
    body,
    headers
  )
end

#count_analytics(engine_name, arguments = {}) ⇒ `Object`

Analytics - Query for analytics counts data Returns the number of clicks and total number of queries over a period

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments
body (Hash) —

a customizable set of options

Options Hash (arguments):

:body (Hash)
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/counts.html

# File 'lib/elastic/app-search/api/count_analytics.rb', line 36

def count_analytics(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name

  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}
  request(
    :post,
    "api/as/v1/engines/#{engine_name}/analytics/counts/",
    arguments,
    body,
    headers
  )
end

#crawler_active_crawl_request(engine_name, arguments = {}) ⇒ `Object`

Crawler - Get active crawl request details Returns active crawl request details.

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments

Options Hash (arguments):

:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/web-crawler-api-reference.html#web-crawler-apis-get-crawler-crawl-requests-active

# File 'lib/elastic/app-search/api/crawler_active_crawl_request.rb', line 33

def crawler_active_crawl_request(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name

  headers = arguments.delete(:headers) || {}
  request(
    :get,
    "api/as/v1/engines/#{engine_name}/crawler/crawl_requests/active/",
    arguments,
    nil,
    headers
  )
end

#crawler_crawl_request(engine_name, arguments = {}) ⇒ `Object`

Crawler - Get crawl request details Returns crawl request details.

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments

Options Hash (arguments):

:crawl_request_id (String) —

Crawl Request ID (Required)
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/web-crawler-api-reference.html#web-crawler-apis-get-crawler-crawl-requests-id

# File 'lib/elastic/app-search/api/crawler_crawl_request.rb', line 34

def crawler_crawl_request(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name
  raise ArgumentError, "Required parameter 'crawl_request_id' missing" unless arguments[:crawl_request_id]

  crawl_request_id = arguments.delete(:crawl_request_id)
  headers = arguments.delete(:headers) || {}
  request(
    :get,
    "api/as/v1/engines/#{engine_name}/crawler/crawl_requests/#{crawl_request_id}/",
    arguments,
    nil,
    headers
  )
end

#crawler_crawl_schedule(engine_name, arguments = {}) ⇒ `Object`

Crawler - Get crawl schedule Returns the current crawl schedule for a given engine

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments

Options Hash (arguments):

:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/web-crawler-api-reference.html#web-crawler-apis-get-crawler-crawl-schedule

# File 'lib/elastic/app-search/api/crawler_crawl_schedule.rb', line 33

def crawler_crawl_schedule(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name

  headers = arguments.delete(:headers) || {}
  request(
    :get,
    "api/as/v1/engines/#{engine_name}/crawler/crawl_schedule/",
    arguments,
    nil,
    headers
  )
end

#crawler_domain(engine_name, arguments = {}) ⇒ `Object`

Crawler - Get domain configuration Returns crawler domain configuration details

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments

Options Hash (arguments):

:domain_id (String) —

Crawler Domain ID (Required)
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/web-crawler-api-reference.html#web-crawler-apis-get-crawler-domain

# File 'lib/elastic/app-search/api/crawler_domain.rb', line 34

def crawler_domain(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name
  raise ArgumentError, "Required parameter 'domain_id' missing" unless arguments[:domain_id]

  domain_id = arguments.delete(:domain_id)
  headers = arguments.delete(:headers) || {}
  request(
    :get,
    "api/as/v1/engines/#{engine_name}/crawler/domains/#{domain_id}/",
    arguments,
    nil,
    headers
  )
end

#crawler_domain_validation_result(arguments = {}) ⇒ `Object`

Crawler - Validate Domain with Crawler Performs a number of checks on a given domain name to make sure it is ready to be crawled and ingested into App Search.

Parameters:

arguments (Hash) (defaults to: {}) —

endpoint arguments
body (Hash) —

a customizable set of options

Options Hash (arguments):

:body (string)
:headers (Hash) —

optional HTTP headers to send with the request

See Also:

https://www.elastic.co/guide/en/app-search/current/web-crawler-api-reference.html#web-crawler-apis-post-crawler-validate-domain

# File 'lib/elastic/app-search/api/crawler_domain_validation_result.rb', line 34

def crawler_domain_validation_result(arguments = {})
  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}
  request(
    :post,
    'api/as/v1/crawler/validate_url/',
    arguments,
    body,
    headers
  )
end

#crawler_metrics(arguments = {}) ⇒ `Object`

Crawler - Retrieve a snapshot of crawler metrics Retrieves a momentary snapshot of key crawler metrics, including global and node-level crawler health

Parameters:

arguments (Hash) (defaults to: {}) —

endpoint arguments

Options Hash (arguments):

:headers (Hash) —

optional HTTP headers to send with the request

See Also:

https://www.elastic.co/guide/en/app-search/current/web-crawler-api-reference.html

# File 'lib/elastic/app-search/api/crawler_metrics.rb', line 32

def crawler_metrics(arguments = {})
  headers = arguments.delete(:headers) || {}
  request(
    :get,
    'api/as/v1/crawler/metrics/',
    arguments,
    nil,
    headers
  )
end

#crawler_overview(engine_name, arguments = {}) ⇒ `Object`

Crawler - Retrieve crawler configuration overview Retrieves crawler configuration overview of a given engine, including configured domains

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments

Options Hash (arguments):

:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/web-crawler-api-reference.html#web-crawler-apis-get-crawler

# File 'lib/elastic/app-search/api/crawler_overview.rb', line 33

def crawler_overview(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name

  headers = arguments.delete(:headers) || {}
  request(
    :get,
    "api/as/v1/engines/#{engine_name}/crawler/",
    arguments,
    nil,
    headers
  )
end

#crawler_process_crawl(engine_name, arguments = {}) ⇒ `Object`

Crawler - Get process crawl details Returns process crawl details.

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments

Options Hash (arguments):

:process_crawl_id (String) —

Process Crawl identifier (Required)
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/web-crawler-api-reference.html#web-crawler-apis-get-crawler-process-crawls-id

# File 'lib/elastic/app-search/api/crawler_process_crawl.rb', line 34

def crawler_process_crawl(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name
  raise ArgumentError, "Required parameter 'process_crawl_id' missing" unless arguments[:process_crawl_id]

  process_crawl_id = arguments.delete(:process_crawl_id)
  headers = arguments.delete(:headers) || {}
  request(
    :get,
    "api/as/v1/engines/#{engine_name}/crawler/process_crawls/#{process_crawl_id}/",
    arguments,
    nil,
    headers
  )
end

#crawler_process_crawl_denied_urls(engine_name, arguments = {}) ⇒ `Object`

Crawler - View denied urls for Process Crawl Provides a sample list of urls identified for deletion by the given process crawl id.

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments

Options Hash (arguments):

:process_crawl_id (String) —

Process Crawl identifier (Required)
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/web-crawler-api-reference.html#web-crawler-apis-get-crawler-process-crawls-id-denied-urls

# File 'lib/elastic/app-search/api/crawler_process_crawl_denied_urls.rb', line 34

def crawler_process_crawl_denied_urls(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name
  raise ArgumentError, "Required parameter 'process_crawl_id' missing" unless arguments[:process_crawl_id]

  process_crawl_id = arguments.delete(:process_crawl_id)
  headers = arguments.delete(:headers) || {}
  request(
    :get,
    "api/as/v1/engines/#{engine_name}/crawler/process_crawls/#{process_crawl_id}/denied_urls/",
    arguments,
    nil,
    headers
  )
end

#crawler_url_extraction_result(engine_name, arguments = {}) ⇒ `Object`

Crawler - Extract content from a URL Performs an HTTP request to a given URL and extracts content from the page using standard App Search Crawler extraction pipeline.

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments
body (Hash) —

a customizable set of options

Options Hash (arguments):

:body (string)
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/web-crawler-api-reference.html#web-crawler-apis-post-crawler-extract-url

# File 'lib/elastic/app-search/api/crawler_url_extraction_result.rb', line 35

def crawler_url_extraction_result(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name

  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}
  request(
    :post,
    "api/as/v1/engines/#{engine_name}/crawler/extract_url/",
    arguments,
    body,
    headers
  )
end

#crawler_url_tracing_result(engine_name, arguments = {}) ⇒ `Object`

Crawler - Trace a history of a crawled URL Returns information about the history of a given URL with the App Search Crawler.

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments
body (Hash) —

a customizable set of options

Options Hash (arguments):

:body (string)
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/web-crawler-api-reference.html#web-crawler-apis-post-crawler-trace-url

# File 'lib/elastic/app-search/api/crawler_url_tracing_result.rb', line 35

def crawler_url_tracing_result(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name

  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}
  request(
    :post,
    "api/as/v1/engines/#{engine_name}/crawler/trace_url/",
    arguments,
    body,
    headers
  )
end

#crawler_url_validation_result(engine_name, arguments = {}) ⇒ `Object`

Crawler - Validate URL with Crawler Performs a number of checks on a given URL to make sure it is ready to be crawled and ingested into App Search.

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments
body (Hash) —

a customizable set of options

Options Hash (arguments):

:body (string)
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/web-crawler-api-reference.html#web-crawler-apis-post-crawler-validate-url

# File 'lib/elastic/app-search/api/crawler_url_validation_result.rb', line 35

def crawler_url_validation_result(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name

  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}
  request(
    :post,
    "api/as/v1/engines/#{engine_name}/crawler/validate_url/",
    arguments,
    body,
    headers
  )
end

#crawler_user_agent(arguments = {}) ⇒ `Object`

Crawler - Get the User-Agent header value for the crawler Retrieves the currently configured value for the User-Agent header used for all Crawler HTTP requests

Parameters:

arguments (Hash) (defaults to: {}) —

endpoint arguments

Options Hash (arguments):

:headers (Hash) —

optional HTTP headers to send with the request

See Also:

https://www.elastic.co/guide/en/app-search/current/web-crawler-api-reference.html#web-crawler-apis-user-agent

# File 'lib/elastic/app-search/api/crawler_user_agent.rb', line 32

def crawler_user_agent(arguments = {})
  headers = arguments.delete(:headers) || {}
  request(
    :get,
    'api/as/v1/crawler/user_agent/',
    arguments,
    nil,
    headers
  )
end

#create_api_key(arguments = {}) ⇒ `Object`

Credentials - Create an API key Creates an App Search API key

Parameters:

arguments (Hash) (defaults to: {}) —

endpoint arguments
body (Hash) —

a customizable set of options

Options Hash (arguments):

:body (Hash) — default: Required: name, type
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/credentials.html#credentials-create

# File 'lib/elastic/app-search/api/create_api_key.rb', line 40

def create_api_key(arguments = {})
  raise ArgumentError, "Required parameter 'body (name,type)' missing" unless arguments[:body]

  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}
  request(
    :post,
    'api/as/v1/credentials/',
    arguments,
    body,
    headers
  )
end

#create_crawler_crawl_request(engine_name, arguments = {}) ⇒ `Object`

Crawler - Create a crawl request Creates a request to perform a crawl of a given engine with the Crawler.

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments
body (Hash) —

a customizable set of options

Options Hash (arguments):

:body (Hash)
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/web-crawler-api-reference.html#web-crawler-apis-post-crawler-crawl-requests

# File 'lib/elastic/app-search/api/create_crawler_crawl_request.rb', line 39

def create_crawler_crawl_request(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name

  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}
  request(
    :post,
    "api/as/v1/engines/#{engine_name}/crawler/crawl_requests/",
    arguments,
    body,
    headers
  )
end

#create_crawler_crawl_rule(engine_name, arguments = {}) ⇒ `Object`

Crawler - Create a crawl rule Creates a crawl rule for a given engine and domain

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments
body (Hash) —

a customizable set of options

Options Hash (arguments):

:domain_id (String) —

Crawler Domain ID (Required)
:body (Hash) — default: Required: order, policy, rule, pattern
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/web-crawler-api-reference.html#web-crawler-apis-post-crawl-rules

# File 'lib/elastic/app-search/api/create_crawler_crawl_rule.rb', line 41

def create_crawler_crawl_rule(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name
  raise ArgumentError, "Required parameter 'domain_id' missing" unless arguments[:domain_id]
  raise ArgumentError, "Required parameter 'body (order,policy,rule,pattern)' missing" unless arguments[:body]

  domain_id = arguments.delete(:domain_id)
  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}
  request(
    :post,
    "api/as/v1/engines/#{engine_name}/crawler/domains/#{domain_id}/crawl_rules/",
    arguments,
    body,
    headers
  )
end

#create_crawler_domain(engine_name, arguments = {}) ⇒ `Object`

Crawler - Create a crawler domain Creates a crawler domain configuration for a given engine

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments
body (Hash) —

a customizable set of options

Options Hash (arguments):

:body (Hash)
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/web-crawler-api-reference.html#web-crawler-apis-post-crawler-domains

# File 'lib/elastic/app-search/api/create_crawler_domain.rb', line 38

def create_crawler_domain(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name

  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}
  request(
    :post,
    "api/as/v1/engines/#{engine_name}/crawler/domains/",
    arguments,
    body,
    headers
  )
end

#create_crawler_entry_point(engine_name, arguments = {}) ⇒ `Object`

Crawler - Create a crawler entry point Creates a crawler domain entry point for a given engine and domain

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments
body (Hash) —

a customizable set of options

Options Hash (arguments):

:domain_id (String) —

Crawler Domain ID (Required)
:body (Hash) — default: Required: value
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/web-crawler-api-reference.html#web-crawler-apis-post-entry-points

# File 'lib/elastic/app-search/api/create_crawler_entry_point.rb', line 38

def create_crawler_entry_point(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name
  raise ArgumentError, "Required parameter 'domain_id' missing" unless arguments[:domain_id]
  raise ArgumentError, "Required parameter 'body (value)' missing" unless arguments[:body]

  domain_id = arguments.delete(:domain_id)
  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}
  request(
    :post,
    "api/as/v1/engines/#{engine_name}/crawler/domains/#{domain_id}/entry_points/",
    arguments,
    body,
    headers
  )
end

#create_crawler_process_crawl(engine_name, arguments = {}) ⇒ `Object`

Crawler - Create a process crawl Queues a task to reprocess crawled documents with current crawl configuration

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments
body (Hash) —

a customizable set of options

Options Hash (arguments):

:body (Hash)
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/web-crawler-api-reference.html#web-crawler-apis-post-crawler-process-crawls

# File 'lib/elastic/app-search/api/create_crawler_process_crawl.rb', line 36

def create_crawler_process_crawl(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name

  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}
  request(
    :post,
    "api/as/v1/engines/#{engine_name}/crawler/process_crawls/",
    arguments,
    body,
    headers
  )
end

#create_crawler_sitemap(engine_name, arguments = {}) ⇒ `Object`

Crawler - Create a crawler sitemap Creates a crawler sitemap configuration for a given engine and domain

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments
body (Hash) —

a customizable set of options

Options Hash (arguments):

:domain_id (String) —

Crawler Domain ID (Required)
:body (Hash) — default: Required: url
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/web-crawler-api-reference.html#web-crawler-apis-post-sitemaps

# File 'lib/elastic/app-search/api/create_crawler_sitemap.rb', line 38

def create_crawler_sitemap(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name
  raise ArgumentError, "Required parameter 'domain_id' missing" unless arguments[:domain_id]
  raise ArgumentError, "Required parameter 'body (url)' missing" unless arguments[:body]

  domain_id = arguments.delete(:domain_id)
  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}
  request(
    :post,
    "api/as/v1/engines/#{engine_name}/crawler/domains/#{domain_id}/sitemaps/",
    arguments,
    body,
    headers
  )
end

#create_curation(engine_name, arguments = {}) ⇒ `Object`

Curations - Create a new curation Create a new curation for the engine

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments
body (Hash) —

a customizable set of options

Options Hash (arguments):

:body (Hash) — default: Required: queries
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/curations.html#curations-create

# File 'lib/elastic/app-search/api/create_curation.rb', line 39

def create_curation(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name
  raise ArgumentError, "Required parameter 'body (queries)' missing" unless arguments[:body]

  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}
  request(
    :post,
    "api/as/v1/engines/#{engine_name}/curations/",
    arguments,
    body,
    headers
  )
end

#create_engine(arguments = {}) ⇒ `Object`

Engines - Create an Engine Creates an App Search Engine

Parameters:

arguments (Hash) (defaults to: {}) —

endpoint arguments
body (Hash) —

a customizable set of options

Options Hash (arguments):

:body (Hash) — default: Required: name
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/engines.html#engines-create

# File 'lib/elastic/app-search/api/create_engine.rb', line 39

def create_engine(arguments = {})
  raise ArgumentError, "Required parameter 'body (name)' missing" unless arguments[:body]

  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}
  request(
    :post,
    'api/as/v1/engines/',
    arguments,
    body,
    headers
  )
end

#create_synonym_set(engine_name, arguments = {}) ⇒ `Object`

Synonyms - Create a synonym set Creates a new synonym set for the engine

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments
body (Hash) —

a customizable set of options

Options Hash (arguments):

:body (Hash) — default: Required: synonyms
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/synonyms.html#synonyms-create

# File 'lib/elastic/app-search/api/create_synonym_set.rb', line 36

def create_synonym_set(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name
  raise ArgumentError, "Required parameter 'body (synonyms)' missing" unless arguments[:body]

  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}
  request(
    :post,
    "api/as/v1/engines/#{engine_name}/synonyms/",
    arguments,
    body,
    headers
  )
end

#curation(engine_name, arguments = {}) ⇒ `Object`

Curations - Retrieve a curation Retrieves a curation by ID

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments

Options Hash (arguments):

:curation_id (String) —

Curation ID (Required)
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/curations.html#curations-read

# File 'lib/elastic/app-search/api/curation.rb', line 34

def curation(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name
  raise ArgumentError, "Required parameter 'curation_id' missing" unless arguments[:curation_id]

  curation_id = arguments.delete(:curation_id)
  headers = arguments.delete(:headers) || {}
  request(
    :get,
    "api/as/v1/engines/#{engine_name}/curations/#{curation_id}/",
    arguments,
    nil,
    headers
  )
end

#delete_active_crawl_request(engine_name, arguments = {}) ⇒ `Object`

Crawler - Cancel an active crawl request Cancels an active crawl request, stopping a running crawl if needed.

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments

Options Hash (arguments):

:body (Hash) —

The request body
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/web-crawler-api-reference.html#web-crawler-apis-post-crawler-crawl-requests-active-cancel

# File 'lib/elastic/app-search/api/delete_active_crawl_request.rb', line 34

def delete_active_crawl_request(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name

  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}

  request(
    :post,
    "api/as/v0/engines/#{engine_name}/crawler/crawl_requests/active/cancel/",
    arguments,
    body,
    headers
  )
end

#delete_api_key(arguments = {}) ⇒ `Object`

Credentials - Delete an API key Deletes a given API key

Parameters:

arguments (Hash) (defaults to: {}) —

endpoint arguments

Options Hash (arguments):

:api_key_name (String) —

Name of an API key (Required)
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/credentials.html#credentials-destroy

# File 'lib/elastic/app-search/api/delete_api_key.rb', line 33

def delete_api_key(arguments = {})
  raise ArgumentError, "Required parameter 'api_key_name' missing" unless arguments[:api_key_name]

  api_key_name = arguments.delete(:api_key_name)
  headers = arguments.delete(:headers) || {}
  request(
    :delete,
    "api/as/v1/credentials/#{api_key_name}/",
    arguments,
    nil,
    headers
  )
end

#delete_crawler_active_crawl_request(engine_name, arguments = {}) ⇒ `Object`

Crawler - Cancel an active crawl request Cancels an active crawl request, stopping a running crawl if needed.

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments

Options Hash (arguments):

:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/web-crawler-api-reference.html#web-crawler-apis-post-crawler-crawl-requests-active-cancel

# File 'lib/elastic/app-search/api/delete_crawler_active_crawl_request.rb', line 33

def delete_crawler_active_crawl_request(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name

  headers = arguments.delete(:headers) || {}
  request(
    :post,
    "api/as/v1/engines/#{engine_name}/crawler/crawl_requests/active/cancel/",
    arguments,
    nil,
    headers
  )
end

#delete_crawler_crawl_rule(engine_name, arguments = {}) ⇒ `Object`

Crawler - Delete a crawl rule Deletes a crawl rule from a given domain

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments

Options Hash (arguments):

:domain_id (String) —

Crawler Domain ID (Required)
:crawl_rule_id (String) —

Crawl Rule ID (Required)
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/web-crawler-api-reference.html#web-crawler-apis-delete-crawl-rule

# File 'lib/elastic/app-search/api/delete_crawler_crawl_rule.rb', line 35

def delete_crawler_crawl_rule(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name
  raise ArgumentError, "Required parameter 'domain_id' missing" unless arguments[:domain_id]
  raise ArgumentError, "Required parameter 'crawl_rule_id' missing" unless arguments[:crawl_rule_id]

  domain_id = arguments.delete(:domain_id)
  crawl_rule_id = arguments.delete(:crawl_rule_id)
  headers = arguments.delete(:headers) || {}
  request(
    :delete,
    "api/as/v1/engines/#{engine_name}/crawler/domains/#{domain_id}/crawl_rules/#{crawl_rule_id}/",
    arguments,
    nil,
    headers
  )
end

#delete_crawler_crawl_schedule(engine_name, arguments = {}) ⇒ `Object`

Crawler - Delete a crawl schedule Deletes a crawl schedule for a given engine

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments

Options Hash (arguments):

:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/web-crawler-api-reference.html#web-crawler-apis-delete-crawler-crawl-schedule

# File 'lib/elastic/app-search/api/delete_crawler_crawl_schedule.rb', line 33

def delete_crawler_crawl_schedule(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name

  headers = arguments.delete(:headers) || {}
  request(
    :delete,
    "api/as/v1/engines/#{engine_name}/crawler/crawl_schedule/",
    arguments,
    nil,
    headers
  )
end

#delete_crawler_domain(engine_name, arguments = {}) ⇒ `Object`

Crawler - Delete domain configuration Deletes crawler domain configuration for a given domain

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments

Options Hash (arguments):

:domain_id (String) —

Crawler Domain ID (Required)
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/web-crawler-api-reference.html#web-crawler-apis-delete-crawler-domain

# File 'lib/elastic/app-search/api/delete_crawler_domain.rb', line 34

def delete_crawler_domain(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name
  raise ArgumentError, "Required parameter 'domain_id' missing" unless arguments[:domain_id]

  domain_id = arguments.delete(:domain_id)
  headers = arguments.delete(:headers) || {}
  request(
    :delete,
    "api/as/v1/engines/#{engine_name}/crawler/domains/#{domain_id}/",
    arguments,
    nil,
    headers
  )
end

#delete_crawler_entry_point(engine_name, arguments = {}) ⇒ `Object`

Crawler - Delete an entry point Deletes a crawler entry point

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments

Options Hash (arguments):

:domain_id (String) —

Crawler Domain ID (Required)
:entry_point_id (String) —

Crawler Entry Point identifier (Required)
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/web-crawler-api-reference.html#web-crawler-apis-delete-crawler-domain

# File 'lib/elastic/app-search/api/delete_crawler_entry_point.rb', line 35

def delete_crawler_entry_point(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name
  raise ArgumentError, "Required parameter 'domain_id' missing" unless arguments[:domain_id]
  raise ArgumentError, "Required parameter 'entry_point_id' missing" unless arguments[:entry_point_id]

  domain_id = arguments.delete(:domain_id)
  entry_point_id = arguments.delete(:entry_point_id)
  headers = arguments.delete(:headers) || {}
  request(
    :delete,
    "api/as/v1/engines/#{engine_name}/crawler/domains/#{domain_id}/entry_points/#{entry_point_id}/",
    arguments,
    nil,
    headers
  )
end

#delete_crawler_sitemap(engine_name, arguments = {}) ⇒ `Object`

Crawler - Delete a sitemap Deletes a sitemap from a given domain

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments

Options Hash (arguments):

:domain_id (String) —

Crawler Domain ID (Required)
:sitemap_id (String) —

Sitemap ID (Required)
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/web-crawler-api-reference.html#web-crawler-apis-delete-sitemap

# File 'lib/elastic/app-search/api/delete_crawler_sitemap.rb', line 35

def delete_crawler_sitemap(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name
  raise ArgumentError, "Required parameter 'domain_id' missing" unless arguments[:domain_id]
  raise ArgumentError, "Required parameter 'sitemap_id' missing" unless arguments[:sitemap_id]

  domain_id = arguments.delete(:domain_id)
  sitemap_id = arguments.delete(:sitemap_id)
  headers = arguments.delete(:headers) || {}
  request(
    :delete,
    "api/as/v1/engines/#{engine_name}/crawler/domains/#{domain_id}/sitemaps/#{sitemap_id}/",
    arguments,
    nil,
    headers
  )
end

#delete_curation(engine_name, arguments = {}) ⇒ `Object`

Curations - Delete a curation Deletes a curation set by ID

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments

Options Hash (arguments):

:curation_id (String) —

Curation ID (Required)
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/curations.html#curations-destroy

# File 'lib/elastic/app-search/api/delete_curation.rb', line 34

def delete_curation(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name
  raise ArgumentError, "Required parameter 'curation_id' missing" unless arguments[:curation_id]

  curation_id = arguments.delete(:curation_id)
  headers = arguments.delete(:headers) || {}
  request(
    :delete,
    "api/as/v1/engines/#{engine_name}/curations/#{curation_id}/",
    arguments,
    nil,
    headers
  )
end

#delete_documents(engine_name, arguments = {}) ⇒ `Object`

Documents - Delete documents by ID Deletes documents for given Document IDs

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments

Options Hash (arguments):

:document_ids (Array<String>)
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/documents.html#documents-delete

# File 'lib/elastic/app-search/api/delete_documents.rb', line 34

def delete_documents(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name

  document_ids = arguments.delete(:document_ids) || {}
  headers = arguments.delete(:headers) || {}
  request(
    :delete,
    "api/as/v1/engines/#{engine_name}/documents/",
    arguments,
    document_ids,
    headers
  )
end

#delete_engine(engine_name, arguments = {}) ⇒ `Object`

Engines - Delete an Engine Delete an engine by name

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments

Options Hash (arguments):

:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/engines.html#engines-delete

# File 'lib/elastic/app-search/api/delete_engine.rb', line 33

def delete_engine(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name

  headers = arguments.delete(:headers) || {}
  request(
    :delete,
    "api/as/v1/engines/#{engine_name}/",
    arguments,
    nil,
    headers
  )
end

#delete_meta_engine_source(engine_name, arguments = {}) ⇒ `Object`

Engines - Delete a source engine Deletes a source engine from a given meta engine

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments

Options Hash (arguments):

:source_engines (Array<String>)
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/meta-engines.html#meta-engines-remove-source-engines

# File 'lib/elastic/app-search/api/delete_meta_engine_source.rb', line 34

def delete_meta_engine_source(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name

  source_engines = arguments.delete(:source_engines) || {}
  headers = arguments.delete(:headers) || {}
  request(
    :delete,
    "api/as/v1/engines/#{engine_name}/source_engines/",
    arguments,
    source_engines,
    headers
  )
end

#delete_synonym_set(engine_name, arguments = {}) ⇒ `Object`

Synonyms - Delete a synonym set Deletes a synonym set by ID

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments

Options Hash (arguments):

:synonym_set_id (String) —

Synonym Set ID (Required)
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/synonyms.html#synonyms-delete

# File 'lib/elastic/app-search/api/delete_synonym_set.rb', line 34

def delete_synonym_set(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name
  raise ArgumentError, "Required parameter 'synonym_set_id' missing" unless arguments[:synonym_set_id]

  synonym_set_id = arguments.delete(:synonym_set_id)
  headers = arguments.delete(:headers) || {}
  request(
    :delete,
    "api/as/v1/engines/#{engine_name}/synonyms/#{synonym_set_id}/",
    arguments,
    nil,
    headers
  )
end

#denied_urls(engine_name, arguments = {}) ⇒ `Object`

Crawler - View denied urls for Process Crawl Provides a sample list of urls identified for deletion by the given process crawl id.

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments

Options Hash (arguments):

:process_crawl_id (String) —

Process Crawl identifier (Required)
:body (Hash) —

The request body
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/web-crawler-api-reference.html

# File 'lib/elastic/app-search/api/denied_urls.rb', line 35

def denied_urls(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name
  raise ArgumentError, "Required parameter 'process_crawl_id' missing" unless arguments[:process_crawl_id]

  process_crawl_id = arguments[:process_crawl_id]
  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}

  request(
    :get,
    "api/as/v0/engines/#{engine_name}/crawler/process_crawls/#{process_crawl_id}/denied_urls/",
    arguments,
    body,
    headers
  )
end

#documents(engine_name, arguments = {}) ⇒ `Object`

Documents - Retrieve one or more documents Retrieves one or more documents by id

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments

Options Hash (arguments):

:ids[] (Array) —

List of Document IDs to fetch
:document_ids (Array<String>)
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/documents.html#documents-get

# File 'lib/elastic/app-search/api/documents.rb', line 35

def documents(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name

  document_ids = arguments.delete(:document_ids) || {}
  headers = arguments.delete(:headers) || {}
  request(
    :get,
    "api/as/v1/engines/#{engine_name}/documents/",
    arguments,
    document_ids,
    headers
  )
end

#engine(engine_name, arguments = {}) ⇒ `Object`

Engines - Retrieve an engine Retrieves details of a given engine by its name

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments

Options Hash (arguments):

:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/engines.html#engines-get

# File 'lib/elastic/app-search/api/engine.rb', line 33

def engine(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name

  headers = arguments.delete(:headers) || {}
  request(
    :get,
    "api/as/v1/engines/#{engine_name}/",
    arguments,
    nil,
    headers
  )
end

#index_documents(engine_name, arguments = {}) ⇒ `Object`

Documents - Create a new document Create or update documents

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments

Options Hash (arguments):

:documents (Array<Hash> { id: [string] })
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/documents.html#documents-create

# File 'lib/elastic/app-search/api/index_documents.rb', line 34

def index_documents(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name

  documents = arguments.delete(:documents) || {}
  headers = arguments.delete(:headers) || {}
  request(
    :post,
    "api/as/v1/engines/#{engine_name}/documents/",
    arguments,
    documents,
    headers
  )
end

#list_adaptive_relevance_suggestions(engine_name, arguments = {}) ⇒ `Object`

AdaptiveRelevanceSuggestions - Retrieve adaptive relevance Retrieve adaptive relevance

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments
body (Hash) —

a customizable set of options

Options Hash (arguments):

:body (Hash)
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/adaptive-relevance-api-reference.html#adaptive-relevance-api-get-engine-adaptive-relevance-suggestions

# File 'lib/elastic/app-search/api/list_adaptive_relevance_suggestions.rb', line 36

def list_adaptive_relevance_suggestions(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name

  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}
  request(
    :post,
    "api/as/v0/engines/#{engine_name}/adaptive_relevance/suggestions/",
    arguments,
    body,
    headers
  )
end

#list_api_keys(arguments = {}) ⇒ `Object`

Credentials - Retrieve all API keys List the details of all API keys

Parameters:

arguments (Hash) (defaults to: {}) —

endpoint arguments

Options Hash (arguments):

:current_page (Integer) —

The page to fetch. Defaults to 1
:page_size (Integer) —

The number of results per page
:headers (Hash) —

optional HTTP headers to send with the request

See Also:

https://www.elastic.co/guide/en/app-search/current/credentials.html#credentials-all

# File 'lib/elastic/app-search/api/list_api_keys.rb', line 34

def list_api_keys(arguments = {})
  headers = arguments.delete(:headers) || {}
  request(
    :get,
    'api/as/v1/credentials/',
    arguments,
    nil,
    headers
  )
end

#list_crawler_crawl_requests(engine_name, arguments = {}) ⇒ `Object`

Crawler - List crawl requests Returns a list of latest crawl requests for a given engine.

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments

Options Hash (arguments):

:current_page (Integer) —

The page to fetch. Defaults to 1
:page_size (Integer) —

The number of results per page
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/web-crawler-api-reference.html#web-crawler-apis-get-crawler-crawl-requests

# File 'lib/elastic/app-search/api/list_crawler_crawl_requests.rb', line 35

def list_crawler_crawl_requests(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name

  headers = arguments.delete(:headers) || {}
  request(
    :get,
    "api/as/v1/engines/#{engine_name}/crawler/crawl_requests/",
    arguments,
    nil,
    headers
  )
end

#list_crawler_domains(engine_name, arguments = {}) ⇒ `Object`

Crawler - List crawler domains Returns a list of crawler domains

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments

Options Hash (arguments):

:current_page (Integer) —

The page to fetch. Defaults to 1
:page_size (Integer) —

The number of results per page
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/web-crawler-api-reference.html#web-crawler-apis-get-crawler-domain

# File 'lib/elastic/app-search/api/list_crawler_domains.rb', line 35

def list_crawler_domains(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name

  headers = arguments.delete(:headers) || {}
  request(
    :get,
    "api/as/v1/engines/#{engine_name}/crawler/domains/",
    arguments,
    nil,
    headers
  )
end

#list_crawler_process_crawls(engine_name, arguments = {}) ⇒ `Object`

Crawler - List process crawls Returns a list of latest process crawls for a given engine

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments

Options Hash (arguments):

:current_page (Integer) —

The page to fetch. Defaults to 1
:page_size (Integer) —

The number of results per page
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/web-crawler-api-reference.html#web-crawler-apis-get-crawler-process-crawls

# File 'lib/elastic/app-search/api/list_crawler_process_crawls.rb', line 35

def list_crawler_process_crawls(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name

  headers = arguments.delete(:headers) || {}
  request(
    :get,
    "api/as/v1/engines/#{engine_name}/crawler/process_crawls/",
    arguments,
    nil,
    headers
  )
end

#list_curations(engine_name, arguments = {}) ⇒ `Object`

Curations - Retrieve all curations Retrieve available curations for the given engine

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments

Options Hash (arguments):

:current_page (Integer) —

The page to fetch. Defaults to 1
:page_size (Integer) —

The number of results per page
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/curations.html#curations-read

# File 'lib/elastic/app-search/api/list_curations.rb', line 35

def list_curations(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name

  headers = arguments.delete(:headers) || {}
  request(
    :get,
    "api/as/v1/engines/#{engine_name}/curations/",
    arguments,
    nil,
    headers
  )
end

#list_documents(engine_name, arguments = {}) ⇒ `Object`

Documents - Retrieve all documents Lists up to 10,000 documents

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments

Options Hash (arguments):

:current_page (Integer) —

The page to fetch. Defaults to 1
:page_size (Integer) —

The number of results per page
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/documents.html#documents-list

# File 'lib/elastic/app-search/api/list_documents.rb', line 35

def list_documents(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name

  headers = arguments.delete(:headers) || {}
  request(
    :get,
    "api/as/v1/engines/#{engine_name}/documents/list/",
    arguments,
    nil,
    headers
  )
end

#list_engines(arguments = {}) ⇒ `Object`

Engines - Retrieve all engines Retrieves all engines with optional pagination support

Parameters:

arguments (Hash) (defaults to: {}) —

endpoint arguments

Options Hash (arguments):

:current_page (Integer) —

The page to fetch. Defaults to 1
:page_size (Integer) —

The number of results per page
:headers (Hash) —

optional HTTP headers to send with the request

See Also:

https://www.elastic.co/guide/en/app-search/current/engines.html#engines-list

# File 'lib/elastic/app-search/api/list_engines.rb', line 34

def list_engines(arguments = {})
  headers = arguments.delete(:headers) || {}
  request(
    :get,
    'api/as/v1/engines/',
    arguments,
    nil,
    headers
  )
end

#list_synonym_sets(engine_name, arguments = {}) ⇒ `Object`

Synonyms - Retrieve all synonym sets Retrieves all available synonym sets for the engine

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments

Options Hash (arguments):

:current_page (Integer) —

The page to fetch. Defaults to 1
:page_size (Integer) —

The number of results per page
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/synonyms.html#synonyms-get

# File 'lib/elastic/app-search/api/list_synonym_sets.rb', line 35

def list_synonym_sets(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name

  headers = arguments.delete(:headers) || {}
  request(
    :get,
    "api/as/v1/engines/#{engine_name}/synonyms/",
    arguments,
    nil,
    headers
  )
end

#log_clickthrough(engine_name, arguments = {}) ⇒ `Object`

Click - Tracks results that were clicked after a query Tracks results that were clicked after a query

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments
body (Hash) —

a customizable set of options

Options Hash (arguments):

:body (Hash) — default: Required: query, document_id
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/clickthrough.html

# File 'lib/elastic/app-search/api/log_clickthrough.rb', line 38

def log_clickthrough(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name
  raise ArgumentError, "Required parameter 'body (query,document_id)' missing" unless arguments[:body]

  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}
  request(
    :post,
    "api/as/v1/engines/#{engine_name}/click/",
    arguments,
    body,
    headers
  )
end

#multi_search(engine_name, arguments = {}) ⇒ `Object`

MultiSearch - Submit a multi search Submit a multi search query and receive a set of results with meta data

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments
body (Hash) —

a customizable set of options

Options Hash (arguments):

:body (Hash) — default: Required: queries
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/multi-search.html

# File 'lib/elastic/app-search/api/multi_search.rb', line 35

def multi_search(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name
  raise ArgumentError, "Required parameter 'body (queries)' missing" unless arguments[:body]

  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}
  request(
    :post,
    "api/as/v1/engines/#{engine_name}/multi_search/",
    arguments,
    body,
    headers
  )
end

#put_adaptive_relevance_settings(engine_name, arguments = {}) ⇒ `Object`

AdaptiveRelevanceSettings - Update adaptive relevance settings Update adaptive relevance settings

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments
body (Hash) —

a customizable set of options

Options Hash (arguments):

:body (Hash) — default: Required: curation
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/adaptive-relevance-api-reference.html#adaptive-relevance-api-put-engine-adaptive-relevance-settings

# File 'lib/elastic/app-search/api/put_adaptive_relevance_settings.rb', line 35

def put_adaptive_relevance_settings(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name
  raise ArgumentError, "Required parameter 'body (curation)' missing" unless arguments[:body]

  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}
  request(
    :put,
    "api/as/v0/engines/#{engine_name}/adaptive_relevance/settings/",
    arguments,
    body,
    headers
  )
end

#put_adaptive_relevance_suggestions(engine_name, arguments = {}) ⇒ `Object`

AdaptiveRelevanceSuggestions - Update adaptive relevance Update adaptive relevance

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments

Options Hash (arguments):

:body (Array<Hash> { query: [string] }, { type: [] }, { status: [] })
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/adaptive-relevance-api-reference.html#adaptive-relevance-api-put-engine-adaptive-relevance-suggestions

# File 'lib/elastic/app-search/api/put_adaptive_relevance_suggestions.rb', line 34

def put_adaptive_relevance_suggestions(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name

  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}
  request(
    :put,
    "api/as/v0/engines/#{engine_name}/adaptive_relevance/suggestions/",
    arguments,
    body,
    headers
  )
end

#put_api_key(arguments = {}) ⇒ `Object`

Credentials - Update an API key Updates an API key

Parameters:

arguments (Hash) (defaults to: {}) —

endpoint arguments
body (Hash) —

a customizable set of options

Options Hash (arguments):

:api_key_name (String) —

Name of an API key (Required)
:body (Hash) — default: Required: name, type
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/credentials.html#credentials-update

# File 'lib/elastic/app-search/api/put_api_key.rb', line 41

def put_api_key(arguments = {})
  raise ArgumentError, "Required parameter 'api_key_name' missing" unless arguments[:api_key_name]
  raise ArgumentError, "Required parameter 'body (name,type)' missing" unless arguments[:body]

  api_key_name = arguments.delete(:api_key_name)
  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}
  request(
    :put,
    "api/as/v1/credentials/#{api_key_name}/",
    arguments,
    body,
    headers
  )
end

#put_crawler_crawl_rule(engine_name, arguments = {}) ⇒ `Object`

Crawler - Update a crawl rule Updates crawl rule configuration

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments
body (Hash) —

a customizable set of options

Options Hash (arguments):

:domain_id (String) —

Crawler Domain ID (Required)
:crawl_rule_id (String) —

Crawl Rule ID (Required)
:body (Hash) — default: Required: order, policy, rule, pattern
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/web-crawler-api-reference.html#web-crawler-apis-put-crawl-rule

# File 'lib/elastic/app-search/api/put_crawler_crawl_rule.rb', line 42

def put_crawler_crawl_rule(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name
  raise ArgumentError, "Required parameter 'domain_id' missing" unless arguments[:domain_id]
  raise ArgumentError, "Required parameter 'crawl_rule_id' missing" unless arguments[:crawl_rule_id]
  raise ArgumentError, "Required parameter 'body (order,policy,rule,pattern)' missing" unless arguments[:body]

  domain_id = arguments.delete(:domain_id)
  crawl_rule_id = arguments.delete(:crawl_rule_id)
  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}
  request(
    :put,
    "api/as/v1/engines/#{engine_name}/crawler/domains/#{domain_id}/crawl_rules/#{crawl_rule_id}/",
    arguments,
    body,
    headers
  )
end

#put_crawler_crawl_schedule(engine_name, arguments = {}) ⇒ `Object`

Crawler - Set crawl schedule Sets up a crawl schedule for a given engine

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments
body (Hash) —

a customizable set of options

Options Hash (arguments):

:body (Hash) — default: Required: frequency, unit
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/web-crawler-api-reference.html#web-crawler-apis-put-crawler-crawl-schedule

# File 'lib/elastic/app-search/api/put_crawler_crawl_schedule.rb', line 36

def put_crawler_crawl_schedule(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name
  raise ArgumentError, "Required parameter 'body (frequency,unit)' missing" unless arguments[:body]

  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}
  request(
    :put,
    "api/as/v1/engines/#{engine_name}/crawler/crawl_schedule/",
    arguments,
    body,
    headers
  )
end

#put_crawler_domain(engine_name, arguments = {}) ⇒ `Object`

Crawler - Update domain configuration Updates crawler domain configuration for a given domain

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments
body (Hash) —

a customizable set of options

Options Hash (arguments):

:domain_id (String) —

Crawler Domain ID (Required)
:body (Hash)
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/web-crawler-api-reference.html#web-crawler-apis-put-crawler-domain

# File 'lib/elastic/app-search/api/put_crawler_domain.rb', line 39

def put_crawler_domain(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name
  raise ArgumentError, "Required parameter 'domain_id' missing" unless arguments[:domain_id]

  domain_id = arguments.delete(:domain_id)
  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}
  request(
    :put,
    "api/as/v1/engines/#{engine_name}/crawler/domains/#{domain_id}/",
    arguments,
    body,
    headers
  )
end

#put_crawler_entry_point(engine_name, arguments = {}) ⇒ `Object`

Crawler - Update a crawler entry point Updates a crawler entry point with a new value

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments
body (Hash) —

a customizable set of options

Options Hash (arguments):

:domain_id (String) —

Crawler Domain ID (Required)
:entry_point_id (String) —

Crawler Entry Point identifier (Required)
:body (Hash) — default: Required: value
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/web-crawler-api-reference.html#web-crawler-apis-put-entry-point

# File 'lib/elastic/app-search/api/put_crawler_entry_point.rb', line 39

def put_crawler_entry_point(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name
  raise ArgumentError, "Required parameter 'domain_id' missing" unless arguments[:domain_id]
  raise ArgumentError, "Required parameter 'entry_point_id' missing" unless arguments[:entry_point_id]
  raise ArgumentError, "Required parameter 'body (value)' missing" unless arguments[:body]

  domain_id = arguments.delete(:domain_id)
  entry_point_id = arguments.delete(:entry_point_id)
  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}
  request(
    :put,
    "api/as/v1/engines/#{engine_name}/crawler/domains/#{domain_id}/entry_points/#{entry_point_id}/",
    arguments,
    body,
    headers
  )
end

#put_crawler_sitemap(engine_name, arguments = {}) ⇒ `Object`

Crawler - Update a sitemap Updates sitemap configuration

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments
body (Hash) —

a customizable set of options

Options Hash (arguments):

:domain_id (String) —

Crawler Domain ID (Required)
:sitemap_id (String) —

Sitemap ID (Required)
:body (Hash) — default: Required: url
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/web-crawler-api-reference.html#web-crawler-apis-put-sitemap

# File 'lib/elastic/app-search/api/put_crawler_sitemap.rb', line 39

def put_crawler_sitemap(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name
  raise ArgumentError, "Required parameter 'domain_id' missing" unless arguments[:domain_id]
  raise ArgumentError, "Required parameter 'sitemap_id' missing" unless arguments[:sitemap_id]
  raise ArgumentError, "Required parameter 'body (url)' missing" unless arguments[:body]

  domain_id = arguments.delete(:domain_id)
  sitemap_id = arguments.delete(:sitemap_id)
  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}
  request(
    :put,
    "api/as/v1/engines/#{engine_name}/crawler/domains/#{domain_id}/sitemaps/#{sitemap_id}/",
    arguments,
    body,
    headers
  )
end

#put_curation(engine_name, arguments = {}) ⇒ `Object`

Curations - Update a curation Updates an existing curation

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments
body (Hash) —

a customizable set of options

Options Hash (arguments):

:curation_id (String) —

Curation ID (Required)
:body (Hash) — default: Required: queries
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/curations.html#curations-update

# File 'lib/elastic/app-search/api/put_curation.rb', line 40

def put_curation(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name
  raise ArgumentError, "Required parameter 'curation_id' missing" unless arguments[:curation_id]
  raise ArgumentError, "Required parameter 'body (queries)' missing" unless arguments[:body]

  curation_id = arguments.delete(:curation_id)
  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}
  request(
    :put,
    "api/as/v1/engines/#{engine_name}/curations/#{curation_id}/",
    arguments,
    body,
    headers
  )
end

#put_documents(engine_name, arguments = {}) ⇒ `Object`

Documents - Partial update of documents Update specific document fields by id and field

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments

Options Hash (arguments):

:documents (Array<Hash> { id: [string] })
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/documents.html#documents-partial

# File 'lib/elastic/app-search/api/put_documents.rb', line 34

def put_documents(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name

  documents = arguments.delete(:documents) || {}
  headers = arguments.delete(:headers) || {}
  request(
    :patch,
    "api/as/v1/engines/#{engine_name}/documents/",
    arguments,
    documents,
    headers
  )
end

#put_schema(engine_name, arguments = {}) ⇒ `Object`

Schema - Update engine schema Update schema for the current engine

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments

Options Hash (arguments):

:schema (Hash)
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/schema.html#schema-patch

# File 'lib/elastic/app-search/api/put_schema.rb', line 34

def put_schema(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name

  schema = arguments.delete(:schema) || {}
  headers = arguments.delete(:headers) || {}
  request(
    :post,
    "api/as/v1/engines/#{engine_name}/schema/",
    arguments,
    schema,
    headers
  )
end

#put_search_settings(engine_name, arguments = {}) ⇒ `Object`

Synonyms - Update search settings Updates search settings for the engine

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments
body (Hash) —

a customizable set of options

Options Hash (arguments):

:body (Hash)
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/search-settings.html#search-settings-update

# File 'lib/elastic/app-search/api/put_search_settings.rb', line 39

def put_search_settings(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name

  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}
  request(
    :put,
    "api/as/v1/engines/#{engine_name}/search_settings/",
    arguments,
    body,
    headers
  )
end

#put_synonym_set(engine_name, arguments = {}) ⇒ `Object`

Synonyms - Update a synonym set Updates a synonym set by ID

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments
body (Hash) —

a customizable set of options

Options Hash (arguments):

:synonym_set_id (String) —

Synonym Set ID (Required)
:body (Hash) — default: Required: synonyms
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/synonyms.html#synonyms-update

# File 'lib/elastic/app-search/api/put_synonym_set.rb', line 37

def put_synonym_set(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name
  raise ArgumentError, "Required parameter 'synonym_set_id' missing" unless arguments[:synonym_set_id]
  raise ArgumentError, "Required parameter 'body (synonyms)' missing" unless arguments[:body]

  synonym_set_id = arguments.delete(:synonym_set_id)
  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}
  request(
    :put,
    "api/as/v1/engines/#{engine_name}/synonyms/#{synonym_set_id}/",
    arguments,
    body,
    headers
  )
end

#query_suggestion(engine_name, arguments = {}) ⇒ `Object`

QuerySuggestion - Retrieve query suggestions Provide relevant query suggestions for incomplete queries

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments
body (Hash) —

a customizable set of options

Options Hash (arguments):

:body (Hash)
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/query-suggestion.html

# File 'lib/elastic/app-search/api/query_suggestion.rb', line 37

def query_suggestion(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name

  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}
  request(
    :post,
    "api/as/v1/engines/#{engine_name}/query_suggestion/",
    arguments,
    body,
    headers
  )
end

#refresh_adaptive_relevance_update_process(engine_name, arguments = {}) ⇒ `Object`

AdaptiveRelevanceSettings - Retrieve adaptive relevance settings Update suggestions process refresh

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments

Options Hash (arguments):

:adaptive_relevance_suggestion_type (String) —

Adaptive relevance suggestion type (Required)
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/adaptive-relevance-api-reference.html#adaptive-relevance-api-post-engine-adaptive-relevance-suggestions-update-process-refresh

# File 'lib/elastic/app-search/api/refresh_adaptive_relevance_update_process.rb', line 34

def refresh_adaptive_relevance_update_process(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name

  unless arguments[:adaptive_relevance_suggestion_type]
    raise ArgumentError,
          "Required parameter 'adaptive_relevance_suggestion_type' missing"
  end

  adaptive_relevance_suggestion_type = arguments.delete(:adaptive_relevance_suggestion_type)
  headers = arguments.delete(:headers) || {}
  request(
    :post,
    "api/as/v0/engines/#{engine_name}/adaptive_relevance/update_process/#{adaptive_relevance_suggestion_type}/refresh/",
    arguments,
    nil,
    headers
  )
end

#reset_search_settings(engine_name, arguments = {}) ⇒ `Object`

Synonyms - Reset search settings Resets search settings for the engine

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments

Options Hash (arguments):

:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/search-settings.html#search-settings-reset

# File 'lib/elastic/app-search/api/reset_search_settings.rb', line 33

def reset_search_settings(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name

  headers = arguments.delete(:headers) || {}
  request(
    :post,
    "api/as/v1/engines/#{engine_name}/search_settings/reset/",
    arguments,
    nil,
    headers
  )
end

#schema(engine_name, arguments = {}) ⇒ `Object`

Schema - Retrieve engine schema Retrieve current schema for the engine

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments

Options Hash (arguments):

:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/schema.html#schema-read

# File 'lib/elastic/app-search/api/schema.rb', line 33

def schema(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name

  headers = arguments.delete(:headers) || {}
  request(
    :get,
    "api/as/v1/engines/#{engine_name}/schema/",
    arguments,
    nil,
    headers
  )
end

#search(engine_name, arguments = {}) ⇒ `Object`

Search - Submit a search Submit a search and receive a set of results with meta data

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments
body (Hash) —

a customizable set of options

Options Hash (arguments):

:body (Hash) — default: Required: query
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/search.html

# File 'lib/elastic/app-search/api/search.rb', line 44

def search(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name
  raise ArgumentError, "Required parameter 'body (query)' missing" unless arguments[:body]

  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}
  request(
    :post,
    "api/as/v1/engines/#{engine_name}/search/",
    arguments,
    body,
    headers
  )
end

#search_es_search(engine_name, arguments = {}) ⇒ `Object`

ElasticsearchSearch - Run a search Execute the provided Elasticsearch search query against an App Search Engine

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments
headers (Hash) —

a customizable set of options

Options Hash (arguments):

:body (Hash) —

Query parameters to be passed to Elasticsearch _search API
:es_search_query_params (Object) —

Query parameters to be passed to Elasticsearch _search API
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/elasticsearch-search-api-reference.html

# File 'lib/elastic/app-search/api/search_es_search.rb', line 37

def search_es_search(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name

  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}
  request(
    :post,
    "api/as/v1/engines/#{engine_name}/elasticsearch/_search/",
    arguments,
    body,
    headers
  )
end

#search_explain(engine_name, arguments = {}) ⇒ `Object`

SearchExplain - Retrieve the search query Submit a search and retrieve an Elasticsearch query

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments
body (Hash) —

a customizable set of options

Options Hash (arguments):

:body (Hash) — default: Required: query
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/search-explain.html

# File 'lib/elastic/app-search/api/search_explain.rb', line 44

def search_explain(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name
  raise ArgumentError, "Required parameter 'body (query)' missing" unless arguments[:body]

  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}
  request(
    :post,
    "api/as/v1/engines/#{engine_name}/search_explain/",
    arguments,
    body,
    headers
  )
end

#search_settings(engine_name, arguments = {}) ⇒ `Object`

SearchSettings - Retrieve search settings Retrieve current search settings for the engine

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments

Options Hash (arguments):

:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/search-settings.html#search-settings-show

# File 'lib/elastic/app-search/api/search_settings.rb', line 33

def search_settings(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name

  headers = arguments.delete(:headers) || {}
  request(
    :get,
    "api/as/v1/engines/#{engine_name}/search_settings/",
    arguments,
    nil,
    headers
  )
end

#synonym_set(engine_name, arguments = {}) ⇒ `Object`

Synonyms - Retrieve a synonym set Retrieves a synonym set by ID

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments

Options Hash (arguments):

:synonym_set_id (String) —

Synonym Set ID (Required)
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/synonyms.html#synonyms-list-one

# File 'lib/elastic/app-search/api/synonym_set.rb', line 34

def synonym_set(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name
  raise ArgumentError, "Required parameter 'synonym_set_id' missing" unless arguments[:synonym_set_id]

  synonym_set_id = arguments.delete(:synonym_set_id)
  headers = arguments.delete(:headers) || {}
  request(
    :get,
    "api/as/v1/engines/#{engine_name}/synonyms/#{synonym_set_id}/",
    arguments,
    nil,
    headers
  )
end

#top_clicks_analytics(engine_name, arguments = {}) ⇒ `Object`

Analytics - Query for analytics click data Returns the number of clicks received by a document in descending order

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments
body (Hash) —

a customizable set of options

Options Hash (arguments):

:body (Hash)
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/clicks.html

# File 'lib/elastic/app-search/api/top_clicks_analytics.rb', line 37

def top_clicks_analytics(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name

  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}
  request(
    :post,
    "api/as/v1/engines/#{engine_name}/analytics/clicks/",
    arguments,
    body,
    headers
  )
end

#top_queries_analytics(engine_name, arguments = {}) ⇒ `Object`

Analytics - Query for analytics query data Returns queries analytics by usage count

Parameters:

engine_name (String) —

Name of the engine (Required)
arguments (Hash) (defaults to: {}) —

endpoint arguments
body (Hash) —

a customizable set of options

Options Hash (arguments):

:body (Hash)
:headers (Hash) —

optional HTTP headers to send with the request

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/app-search/current/queries.html#queries-top-queries

# File 'lib/elastic/app-search/api/top_queries_analytics.rb', line 36

def top_queries_analytics(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name

  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}
  request(
    :post,
    "api/as/v1/engines/#{engine_name}/analytics/queries/",
    arguments,
    body,
    headers
  )
end

Module: Elastic::EnterpriseSearch::AppSearch::Actions

Instance Method Summary collapse

Instance Method Details

#adaptive_relevance_settings(engine_name, arguments = {}) ⇒ Object

#adaptive_relevance_suggestions(engine_name, arguments = {}) ⇒ Object

#add_meta_engine_source(engine_name, arguments = {}) ⇒ Object

#api_key(arguments = {}) ⇒ Object

#api_logs(engine_name, arguments = {}) ⇒ Object

#count_analytics(engine_name, arguments = {}) ⇒ Object

#crawler_active_crawl_request(engine_name, arguments = {}) ⇒ Object

#crawler_crawl_request(engine_name, arguments = {}) ⇒ Object

#crawler_crawl_schedule(engine_name, arguments = {}) ⇒ Object

#crawler_domain(engine_name, arguments = {}) ⇒ Object

#crawler_domain_validation_result(arguments = {}) ⇒ Object

#crawler_metrics(arguments = {}) ⇒ Object

#crawler_overview(engine_name, arguments = {}) ⇒ Object

#crawler_process_crawl(engine_name, arguments = {}) ⇒ Object

#crawler_process_crawl_denied_urls(engine_name, arguments = {}) ⇒ Object

#crawler_url_extraction_result(engine_name, arguments = {}) ⇒ Object

#crawler_url_tracing_result(engine_name, arguments = {}) ⇒ Object

#crawler_url_validation_result(engine_name, arguments = {}) ⇒ Object

#crawler_user_agent(arguments = {}) ⇒ Object

#create_api_key(arguments = {}) ⇒ Object

#create_crawler_crawl_request(engine_name, arguments = {}) ⇒ Object

#create_crawler_crawl_rule(engine_name, arguments = {}) ⇒ Object

#create_crawler_domain(engine_name, arguments = {}) ⇒ Object

#create_crawler_entry_point(engine_name, arguments = {}) ⇒ Object

#create_crawler_process_crawl(engine_name, arguments = {}) ⇒ Object

#create_crawler_sitemap(engine_name, arguments = {}) ⇒ Object

#create_curation(engine_name, arguments = {}) ⇒ Object

#create_engine(arguments = {}) ⇒ Object

#create_synonym_set(engine_name, arguments = {}) ⇒ Object

#curation(engine_name, arguments = {}) ⇒ Object

#delete_active_crawl_request(engine_name, arguments = {}) ⇒ Object

#delete_api_key(arguments = {}) ⇒ Object

#delete_crawler_active_crawl_request(engine_name, arguments = {}) ⇒ Object

#delete_crawler_crawl_rule(engine_name, arguments = {}) ⇒ Object

#delete_crawler_crawl_schedule(engine_name, arguments = {}) ⇒ Object

#delete_crawler_domain(engine_name, arguments = {}) ⇒ Object

#delete_crawler_entry_point(engine_name, arguments = {}) ⇒ Object

#delete_crawler_sitemap(engine_name, arguments = {}) ⇒ Object

#delete_curation(engine_name, arguments = {}) ⇒ Object

#delete_documents(engine_name, arguments = {}) ⇒ Object

#delete_engine(engine_name, arguments = {}) ⇒ Object

#delete_meta_engine_source(engine_name, arguments = {}) ⇒ Object

#delete_synonym_set(engine_name, arguments = {}) ⇒ Object

#denied_urls(engine_name, arguments = {}) ⇒ Object

#documents(engine_name, arguments = {}) ⇒ Object

#engine(engine_name, arguments = {}) ⇒ Object

#index_documents(engine_name, arguments = {}) ⇒ Object

#list_adaptive_relevance_suggestions(engine_name, arguments = {}) ⇒ Object

#list_api_keys(arguments = {}) ⇒ Object

#list_crawler_crawl_requests(engine_name, arguments = {}) ⇒ Object

#list_crawler_domains(engine_name, arguments = {}) ⇒ Object

#list_crawler_process_crawls(engine_name, arguments = {}) ⇒ Object

#list_curations(engine_name, arguments = {}) ⇒ Object

#list_documents(engine_name, arguments = {}) ⇒ Object

#list_engines(arguments = {}) ⇒ Object

#list_synonym_sets(engine_name, arguments = {}) ⇒ Object

#log_clickthrough(engine_name, arguments = {}) ⇒ Object

#multi_search(engine_name, arguments = {}) ⇒ Object

#put_adaptive_relevance_settings(engine_name, arguments = {}) ⇒ Object

#put_adaptive_relevance_suggestions(engine_name, arguments = {}) ⇒ Object

#put_api_key(arguments = {}) ⇒ Object

#put_crawler_crawl_rule(engine_name, arguments = {}) ⇒ Object

#put_crawler_crawl_schedule(engine_name, arguments = {}) ⇒ Object

#put_crawler_domain(engine_name, arguments = {}) ⇒ Object

#put_crawler_entry_point(engine_name, arguments = {}) ⇒ Object

#put_crawler_sitemap(engine_name, arguments = {}) ⇒ Object

#put_curation(engine_name, arguments = {}) ⇒ Object

#put_documents(engine_name, arguments = {}) ⇒ Object

#put_schema(engine_name, arguments = {}) ⇒ Object

#put_search_settings(engine_name, arguments = {}) ⇒ Object

#put_synonym_set(engine_name, arguments = {}) ⇒ Object

#query_suggestion(engine_name, arguments = {}) ⇒ Object

#refresh_adaptive_relevance_update_process(engine_name, arguments = {}) ⇒ Object

#reset_search_settings(engine_name, arguments = {}) ⇒ Object

#schema(engine_name, arguments = {}) ⇒ Object

#search(engine_name, arguments = {}) ⇒ Object

#search_es_search(engine_name, arguments = {}) ⇒ Object

#adaptive_relevance_settings(engine_name, arguments = {}) ⇒ `Object`

#adaptive_relevance_suggestions(engine_name, arguments = {}) ⇒ `Object`

#add_meta_engine_source(engine_name, arguments = {}) ⇒ `Object`

#api_key(arguments = {}) ⇒ `Object`

#api_logs(engine_name, arguments = {}) ⇒ `Object`

#count_analytics(engine_name, arguments = {}) ⇒ `Object`

#crawler_active_crawl_request(engine_name, arguments = {}) ⇒ `Object`

#crawler_crawl_request(engine_name, arguments = {}) ⇒ `Object`

#crawler_crawl_schedule(engine_name, arguments = {}) ⇒ `Object`

#crawler_domain(engine_name, arguments = {}) ⇒ `Object`

#crawler_domain_validation_result(arguments = {}) ⇒ `Object`

#crawler_metrics(arguments = {}) ⇒ `Object`

#crawler_overview(engine_name, arguments = {}) ⇒ `Object`

#crawler_process_crawl(engine_name, arguments = {}) ⇒ `Object`

#crawler_process_crawl_denied_urls(engine_name, arguments = {}) ⇒ `Object`

#crawler_url_extraction_result(engine_name, arguments = {}) ⇒ `Object`

#crawler_url_tracing_result(engine_name, arguments = {}) ⇒ `Object`

#crawler_url_validation_result(engine_name, arguments = {}) ⇒ `Object`

#crawler_user_agent(arguments = {}) ⇒ `Object`

#create_api_key(arguments = {}) ⇒ `Object`

#create_crawler_crawl_request(engine_name, arguments = {}) ⇒ `Object`

#create_crawler_crawl_rule(engine_name, arguments = {}) ⇒ `Object`

#create_crawler_domain(engine_name, arguments = {}) ⇒ `Object`

#create_crawler_entry_point(engine_name, arguments = {}) ⇒ `Object`

#create_crawler_process_crawl(engine_name, arguments = {}) ⇒ `Object`

#create_crawler_sitemap(engine_name, arguments = {}) ⇒ `Object`

#create_curation(engine_name, arguments = {}) ⇒ `Object`

#create_engine(arguments = {}) ⇒ `Object`

#create_synonym_set(engine_name, arguments = {}) ⇒ `Object`

#curation(engine_name, arguments = {}) ⇒ `Object`

#delete_active_crawl_request(engine_name, arguments = {}) ⇒ `Object`

#delete_api_key(arguments = {}) ⇒ `Object`

#delete_crawler_active_crawl_request(engine_name, arguments = {}) ⇒ `Object`

#delete_crawler_crawl_rule(engine_name, arguments = {}) ⇒ `Object`

#delete_crawler_crawl_schedule(engine_name, arguments = {}) ⇒ `Object`

#delete_crawler_domain(engine_name, arguments = {}) ⇒ `Object`

#delete_crawler_entry_point(engine_name, arguments = {}) ⇒ `Object`

#delete_crawler_sitemap(engine_name, arguments = {}) ⇒ `Object`

#delete_curation(engine_name, arguments = {}) ⇒ `Object`

#delete_documents(engine_name, arguments = {}) ⇒ `Object`

#delete_engine(engine_name, arguments = {}) ⇒ `Object`

#delete_meta_engine_source(engine_name, arguments = {}) ⇒ `Object`

#delete_synonym_set(engine_name, arguments = {}) ⇒ `Object`

#denied_urls(engine_name, arguments = {}) ⇒ `Object`

#documents(engine_name, arguments = {}) ⇒ `Object`

#engine(engine_name, arguments = {}) ⇒ `Object`

#index_documents(engine_name, arguments = {}) ⇒ `Object`

#list_adaptive_relevance_suggestions(engine_name, arguments = {}) ⇒ `Object`

#list_api_keys(arguments = {}) ⇒ `Object`

#list_crawler_crawl_requests(engine_name, arguments = {}) ⇒ `Object`

#list_crawler_domains(engine_name, arguments = {}) ⇒ `Object`

#list_crawler_process_crawls(engine_name, arguments = {}) ⇒ `Object`

#list_curations(engine_name, arguments = {}) ⇒ `Object`

#list_documents(engine_name, arguments = {}) ⇒ `Object`

#list_engines(arguments = {}) ⇒ `Object`

#list_synonym_sets(engine_name, arguments = {}) ⇒ `Object`

#log_clickthrough(engine_name, arguments = {}) ⇒ `Object`

#multi_search(engine_name, arguments = {}) ⇒ `Object`

#put_adaptive_relevance_settings(engine_name, arguments = {}) ⇒ `Object`

#put_adaptive_relevance_suggestions(engine_name, arguments = {}) ⇒ `Object`

#put_api_key(arguments = {}) ⇒ `Object`

#put_crawler_crawl_rule(engine_name, arguments = {}) ⇒ `Object`

#put_crawler_crawl_schedule(engine_name, arguments = {}) ⇒ `Object`

#put_crawler_domain(engine_name, arguments = {}) ⇒ `Object`

#put_crawler_entry_point(engine_name, arguments = {}) ⇒ `Object`

#put_crawler_sitemap(engine_name, arguments = {}) ⇒ `Object`

#put_curation(engine_name, arguments = {}) ⇒ `Object`

#put_documents(engine_name, arguments = {}) ⇒ `Object`

#put_schema(engine_name, arguments = {}) ⇒ `Object`

#put_search_settings(engine_name, arguments = {}) ⇒ `Object`

#put_synonym_set(engine_name, arguments = {}) ⇒ `Object`

#query_suggestion(engine_name, arguments = {}) ⇒ `Object`

#refresh_adaptive_relevance_update_process(engine_name, arguments = {}) ⇒ `Object`

#reset_search_settings(engine_name, arguments = {}) ⇒ `Object`

#schema(engine_name, arguments = {}) ⇒ `Object`

#search(engine_name, arguments = {}) ⇒ `Object`

#search_es_search(engine_name, arguments = {}) ⇒ `Object`

#search_explain(engine_name, arguments = {}) ⇒ `Object`

#search_settings(engine_name, arguments = {}) ⇒ `Object`

#synonym_set(engine_name, arguments = {}) ⇒ `Object`