packages/enterprise-search/src/api/app/api.ts

/*
 * Licensed to Elasticsearch B.V. under one or more contributor
 * license agreements. See the NOTICE file distributed with
 * this work for additional information regarding copyright
 * ownership. Elasticsearch B.V. licenses this file to you under
 * the Apache License, Version 2.0 (the "License"); you may
 * not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

/* eslint-disable @typescript-eslint/naming-convention */
/* eslint-disable @typescript-eslint/no-empty-interface */

// This file was automatically generated by elastic/elastic-client-generator-js
// DO NOT MODIFY IT BY HAND. Instead, modify the source open api file,
// and elastic/elastic-client-generator-js to regenerate this file again.

import {
  Transport,
  TransportRequestOptions
} from '@elastic/transport'
import * as T from './types'
interface That { transport: Transport }

export default class API {
  async getAdaptiveRelevanceSettings (this: That, params: T.GetAdaptiveRelevanceSettingsRequest, options?: TransportRequestOptions): Promise<T.GetAdaptiveRelevanceSettingsResponse> {
    const {
      engine_name,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.GetAdaptiveRelevanceSettingsResponse>({
      method: 'GET',
      path: `/api/as/v0/engines/${engine_name}/adaptive_relevance/settings`,
      querystring
    }, options)
  }

  async putAdaptiveRelevanceSettings (this: That, params: T.PutAdaptiveRelevanceSettingsRequest, options?: TransportRequestOptions): Promise<T.PutAdaptiveRelevanceSettingsResponse> {
    const {
      engine_name,
      body,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.PutAdaptiveRelevanceSettingsResponse>({
      method: 'PUT',
      path: `/api/as/v0/engines/${engine_name}/adaptive_relevance/settings`,
      querystring,
      body: body
    }, options)
  }

  async listAdaptiveRelevanceSuggestions (this: That, params: T.ListAdaptiveRelevanceSuggestionsRequest, options?: TransportRequestOptions): Promise<T.ListAdaptiveRelevanceSuggestionsResponse> {
    const {
      engine_name,
      body,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.ListAdaptiveRelevanceSuggestionsResponse>({
      method: 'POST',
      path: `/api/as/v0/engines/${engine_name}/adaptive_relevance/suggestions`,
      querystring,
      body: body
    }, options)
  }

  async putAdaptiveRelevanceSuggestions (this: That, params: T.PutAdaptiveRelevanceSuggestionsRequest, options?: TransportRequestOptions): Promise<T.PutAdaptiveRelevanceSuggestionsResponse> {
    const {
      engine_name,
      body,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.PutAdaptiveRelevanceSuggestionsResponse>({
      method: 'PUT',
      path: `/api/as/v0/engines/${engine_name}/adaptive_relevance/suggestions`,
      querystring,
      body: body
    }, options)
  }

  async getAdaptiveRelevanceSuggestions (this: That, params: T.GetAdaptiveRelevanceSuggestionsRequest, options?: TransportRequestOptions): Promise<T.GetAdaptiveRelevanceSuggestionsResponse> {
    const {
      engine_name,
      search_suggestion_query,
      body,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.GetAdaptiveRelevanceSuggestionsResponse>({
      method: 'POST',
      path: `/api/as/v0/engines/${engine_name}/adaptive_relevance/suggestions/${search_suggestion_query}`,
      querystring,
      body: body
    }, options)
  }

  async refreshAdaptiveRelevanceUpdateProcess (this: That, params: T.RefreshAdaptiveRelevanceUpdateProcessRequest, options?: TransportRequestOptions): Promise<T.RefreshAdaptiveRelevanceUpdateProcessResponse> {
    const {
      engine_name,
      adaptive_relevance_suggestion_type,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.RefreshAdaptiveRelevanceUpdateProcessResponse>({
      method: 'POST',
      path: `/api/as/v0/engines/${engine_name}/adaptive_relevance/update_process/${adaptive_relevance_suggestion_type}/refresh`,
      querystring
    }, options)
  }

  async getTopClicksAnalytics (this: That, params: T.GetTopClicksAnalyticsRequest, options?: TransportRequestOptions): Promise<T.GetTopClicksAnalyticsResponse> {
    const {
      engine_name,
      body,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.GetTopClicksAnalyticsResponse>({
      method: 'POST',
      path: `/api/as/v1/engines/${engine_name}/analytics/clicks`,
      querystring,
      body: body
    }, options)
  }

  async getCountAnalytics (this: That, params: T.GetCountAnalyticsRequest, options?: TransportRequestOptions): Promise<T.GetCountAnalyticsResponse> {
    const {
      engine_name,
      body,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.GetCountAnalyticsResponse>({
      method: 'POST',
      path: `/api/as/v1/engines/${engine_name}/analytics/counts`,
      querystring,
      body: body
    }, options)
  }

  async getTopQueriesAnalytics (this: That, params: T.GetTopQueriesAnalyticsRequest, options?: TransportRequestOptions): Promise<T.GetTopQueriesAnalyticsResponse> {
    const {
      engine_name,
      body,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.GetTopQueriesAnalyticsResponse>({
      method: 'POST',
      path: `/api/as/v1/engines/${engine_name}/analytics/queries`,
      querystring,
      body: body
    }, options)
  }

  async logClickthrough (this: That, params: T.LogClickthroughRequest, options?: TransportRequestOptions): Promise<T.LogClickthroughResponse> {
    const {
      engine_name,
      body,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.LogClickthroughResponse>({
      method: 'POST',
      path: `/api/as/v1/engines/${engine_name}/click`,
      querystring,
      body: body
    }, options)
  }

  async getCrawlerUrlExtractionResult (this: That, params: T.GetCrawlerUrlExtractionResultRequest, options?: TransportRequestOptions): Promise<T.GetCrawlerUrlExtractionResultResponse> {
    const {
      engine_name,
      body,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.GetCrawlerUrlExtractionResultResponse>({
      method: 'POST',
      path: `/api/as/v1/engines/${engine_name}/crawler/extract_url`,
      querystring,
      body: body
    }, options)
  }

  async createCrawlerCrawlRequest (this: That, params: T.CreateCrawlerCrawlRequestRequest, options?: TransportRequestOptions): Promise<T.CreateCrawlerCrawlRequestResponse> {
    const {
      engine_name,
      body,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.CreateCrawlerCrawlRequestResponse>({
      method: 'POST',
      path: `/api/as/v1/engines/${engine_name}/crawler/crawl_requests`,
      querystring,
      body: body
    }, options)
  }

  async listCrawlerCrawlRequests (this: That, params: T.ListCrawlerCrawlRequestsRequest, options?: TransportRequestOptions): Promise<T.ListCrawlerCrawlRequestsResponse> {
    const {
      engine_name,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.ListCrawlerCrawlRequestsResponse>({
      method: 'GET',
      path: `/api/as/v1/engines/${engine_name}/crawler/crawl_requests`,
      querystring
    }, options)
  }

  async getCrawlerCrawlRequest (this: That, params: T.GetCrawlerCrawlRequestRequest, options?: TransportRequestOptions): Promise<T.GetCrawlerCrawlRequestResponse> {
    const {
      engine_name,
      crawl_request_id,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.GetCrawlerCrawlRequestResponse>({
      method: 'GET',
      path: `/api/as/v1/engines/${engine_name}/crawler/crawl_requests/${crawl_request_id}`,
      querystring
    }, options)
  }

  async getCrawlerActiveCrawlRequest (this: That, params: T.GetCrawlerActiveCrawlRequestRequest, options?: TransportRequestOptions): Promise<T.GetCrawlerActiveCrawlRequestResponse> {
    const {
      engine_name,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.GetCrawlerActiveCrawlRequestResponse>({
      method: 'GET',
      path: `/api/as/v1/engines/${engine_name}/crawler/crawl_requests/active`,
      querystring
    }, options)
  }

  async deleteCrawlerActiveCrawlRequest (this: That, params: T.DeleteCrawlerActiveCrawlRequestRequest, options?: TransportRequestOptions): Promise<T.DeleteCrawlerActiveCrawlRequestResponse> {
    const {
      engine_name,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.DeleteCrawlerActiveCrawlRequestResponse>({
      method: 'POST',
      path: `/api/as/v1/engines/${engine_name}/crawler/crawl_requests/active/cancel`,
      querystring
    }, options)
  }

  async createCrawlerCrawlRule (this: That, params: T.CreateCrawlerCrawlRuleRequest, options?: TransportRequestOptions): Promise<T.CreateCrawlerCrawlRuleResponse> {
    const {
      engine_name,
      domain_id,
      body,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.CreateCrawlerCrawlRuleResponse>({
      method: 'POST',
      path: `/api/as/v1/engines/${engine_name}/crawler/domains/${domain_id}/crawl_rules`,
      querystring,
      body: body
    }, options)
  }

  async putCrawlerCrawlRule (this: That, params: T.PutCrawlerCrawlRuleRequest, options?: TransportRequestOptions): Promise<T.PutCrawlerCrawlRuleResponse> {
    const {
      engine_name,
      domain_id,
      crawl_rule_id,
      body,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.PutCrawlerCrawlRuleResponse>({
      method: 'PUT',
      path: `/api/as/v1/engines/${engine_name}/crawler/domains/${domain_id}/crawl_rules/${crawl_rule_id}`,
      querystring,
      body: body
    }, options)
  }

  async deleteCrawlerCrawlRule (this: That, params: T.DeleteCrawlerCrawlRuleRequest, options?: TransportRequestOptions): Promise<T.DeleteCrawlerCrawlRuleResponse> {
    const {
      engine_name,
      domain_id,
      crawl_rule_id,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.DeleteCrawlerCrawlRuleResponse>({
      method: 'DELETE',
      path: `/api/as/v1/engines/${engine_name}/crawler/domains/${domain_id}/crawl_rules/${crawl_rule_id}`,
      querystring
    }, options)
  }

  async getCrawlerCrawlSchedule (this: That, params: T.GetCrawlerCrawlScheduleRequest, options?: TransportRequestOptions): Promise<T.GetCrawlerCrawlScheduleResponse> {
    const {
      engine_name,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.GetCrawlerCrawlScheduleResponse>({
      method: 'GET',
      path: `/api/as/v1/engines/${engine_name}/crawler/crawl_schedule`,
      querystring
    }, options)
  }

  async putCrawlerCrawlSchedule (this: That, params: T.PutCrawlerCrawlScheduleRequest, options?: TransportRequestOptions): Promise<T.PutCrawlerCrawlScheduleResponse> {
    const {
      engine_name,
      body,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.PutCrawlerCrawlScheduleResponse>({
      method: 'PUT',
      path: `/api/as/v1/engines/${engine_name}/crawler/crawl_schedule`,
      querystring,
      body: body
    }, options)
  }

  async deleteCrawlerCrawlSchedule (this: That, params: T.DeleteCrawlerCrawlScheduleRequest, options?: TransportRequestOptions): Promise<T.DeleteCrawlerCrawlScheduleResponse> {
    const {
      engine_name,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.DeleteCrawlerCrawlScheduleResponse>({
      method: 'DELETE',
      path: `/api/as/v1/engines/${engine_name}/crawler/crawl_schedule`,
      querystring
    }, options)
  }

  async getCrawlerProcessCrawlDeniedUrls (this: That, params: T.GetCrawlerProcessCrawlDeniedUrlsRequest, options?: TransportRequestOptions): Promise<T.GetCrawlerProcessCrawlDeniedUrlsResponse> {
    const {
      engine_name,
      process_crawl_id,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.GetCrawlerProcessCrawlDeniedUrlsResponse>({
      method: 'GET',
      path: `/api/as/v1/engines/${engine_name}/crawler/process_crawls/${process_crawl_id}/denied_urls`,
      querystring
    }, options)
  }

  async listCrawlerDomains (this: That, params: T.ListCrawlerDomainsRequest, options?: TransportRequestOptions): Promise<T.ListCrawlerDomainsResponse> {
    const {
      engine_name,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.ListCrawlerDomainsResponse>({
      method: 'GET',
      path: `/api/as/v1/engines/${engine_name}/crawler/domains`,
      querystring
    }, options)
  }

  async createCrawlerDomain (this: That, params: T.CreateCrawlerDomainRequest, options?: TransportRequestOptions): Promise<T.CreateCrawlerDomainResponse> {
    const {
      engine_name,
      body,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.CreateCrawlerDomainResponse>({
      method: 'POST',
      path: `/api/as/v1/engines/${engine_name}/crawler/domains`,
      querystring,
      body: body
    }, options)
  }

  async getCrawlerDomain (this: That, params: T.GetCrawlerDomainRequest, options?: TransportRequestOptions): Promise<T.GetCrawlerDomainResponse> {
    const {
      engine_name,
      domain_id,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.GetCrawlerDomainResponse>({
      method: 'GET',
      path: `/api/as/v1/engines/${engine_name}/crawler/domains/${domain_id}`,
      querystring
    }, options)
  }

  async putCrawlerDomain (this: That, params: T.PutCrawlerDomainRequest, options?: TransportRequestOptions): Promise<T.PutCrawlerDomainResponse> {
    const {
      engine_name,
      domain_id,
      body,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.PutCrawlerDomainResponse>({
      method: 'PUT',
      path: `/api/as/v1/engines/${engine_name}/crawler/domains/${domain_id}`,
      querystring,
      body: body
    }, options)
  }

  async deleteCrawlerDomain (this: That, params: T.DeleteCrawlerDomainRequest, options?: TransportRequestOptions): Promise<T.DeleteCrawlerDomainResponse> {
    const {
      engine_name,
      domain_id,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.DeleteCrawlerDomainResponse>({
      method: 'DELETE',
      path: `/api/as/v1/engines/${engine_name}/crawler/domains/${domain_id}`,
      querystring
    }, options)
  }

  async createCrawlerEntryPoint (this: That, params: T.CreateCrawlerEntryPointRequest, options?: TransportRequestOptions): Promise<T.CreateCrawlerEntryPointResponse> {
    const {
      engine_name,
      domain_id,
      body,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.CreateCrawlerEntryPointResponse>({
      method: 'POST',
      path: `/api/as/v1/engines/${engine_name}/crawler/domains/${domain_id}/entry_points`,
      querystring,
      body: body
    }, options)
  }

  async putCrawlerEntryPoint (this: That, params: T.PutCrawlerEntryPointRequest, options?: TransportRequestOptions): Promise<T.PutCrawlerEntryPointResponse> {
    const {
      engine_name,
      domain_id,
      entry_point_id,
      body,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.PutCrawlerEntryPointResponse>({
      method: 'PUT',
      path: `/api/as/v1/engines/${engine_name}/crawler/domains/${domain_id}/entry_points/${entry_point_id}`,
      querystring,
      body: body
    }, options)
  }

  async deleteCrawlerEntryPoint (this: That, params: T.DeleteCrawlerEntryPointRequest, options?: TransportRequestOptions): Promise<T.DeleteCrawlerEntryPointResponse> {
    const {
      engine_name,
      domain_id,
      entry_point_id,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.DeleteCrawlerEntryPointResponse>({
      method: 'DELETE',
      path: `/api/as/v1/engines/${engine_name}/crawler/domains/${domain_id}/entry_points/${entry_point_id}`,
      querystring
    }, options)
  }

  async getCrawlerMetrics (this: That, params?: T.GetCrawlerMetricsRequest, options?: TransportRequestOptions): Promise<T.GetCrawlerMetricsResponse> {
    return await this.transport.request<T.GetCrawlerMetricsResponse>({
      method: 'GET',
      path: '/api/as/v1/crawler/metrics'
    }, options)
  }

  async getCrawlerOverview (this: That, params: T.GetCrawlerOverviewRequest, options?: TransportRequestOptions): Promise<T.GetCrawlerOverviewResponse> {
    const {
      engine_name,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.GetCrawlerOverviewResponse>({
      method: 'GET',
      path: `/api/as/v1/engines/${engine_name}/crawler`,
      querystring
    }, options)
  }

  async createCrawlerProcessCrawl (this: That, params: T.CreateCrawlerProcessCrawlRequest, options?: TransportRequestOptions): Promise<T.CreateCrawlerProcessCrawlResponse> {
    const {
      engine_name,
      body,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.CreateCrawlerProcessCrawlResponse>({
      method: 'POST',
      path: `/api/as/v1/engines/${engine_name}/crawler/process_crawls`,
      querystring,
      body: body
    }, options)
  }

  async listCrawlerProcessCrawls (this: That, params: T.ListCrawlerProcessCrawlsRequest, options?: TransportRequestOptions): Promise<T.ListCrawlerProcessCrawlsResponse> {
    const {
      engine_name,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.ListCrawlerProcessCrawlsResponse>({
      method: 'GET',
      path: `/api/as/v1/engines/${engine_name}/crawler/process_crawls`,
      querystring
    }, options)
  }

  async getCrawlerProcessCrawl (this: That, params: T.GetCrawlerProcessCrawlRequest, options?: TransportRequestOptions): Promise<T.GetCrawlerProcessCrawlResponse> {
    const {
      engine_name,
      process_crawl_id,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.GetCrawlerProcessCrawlResponse>({
      method: 'GET',
      path: `/api/as/v1/engines/${engine_name}/crawler/process_crawls/${process_crawl_id}`,
      querystring
    }, options)
  }

  async createCrawlerSitemap (this: That, params: T.CreateCrawlerSitemapRequest, options?: TransportRequestOptions): Promise<T.CreateCrawlerSitemapResponse> {
    const {
      engine_name,
      domain_id,
      body,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.CreateCrawlerSitemapResponse>({
      method: 'POST',
      path: `/api/as/v1/engines/${engine_name}/crawler/domains/${domain_id}/sitemaps`,
      querystring,
      body: body
    }, options)
  }

  async putCrawlerSitemap (this: That, params: T.PutCrawlerSitemapRequest, options?: TransportRequestOptions): Promise<T.PutCrawlerSitemapResponse> {
    const {
      engine_name,
      domain_id,
      sitemap_id,
      body,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.PutCrawlerSitemapResponse>({
      method: 'PUT',
      path: `/api/as/v1/engines/${engine_name}/crawler/domains/${domain_id}/sitemaps/${sitemap_id}`,
      querystring,
      body: body
    }, options)
  }

  async deleteCrawlerSitemap (this: That, params: T.DeleteCrawlerSitemapRequest, options?: TransportRequestOptions): Promise<T.DeleteCrawlerSitemapResponse> {
    const {
      engine_name,
      domain_id,
      sitemap_id,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.DeleteCrawlerSitemapResponse>({
      method: 'DELETE',
      path: `/api/as/v1/engines/${engine_name}/crawler/domains/${domain_id}/sitemaps/${sitemap_id}`,
      querystring
    }, options)
  }

  async getCrawlerUrlTracingResult (this: That, params: T.GetCrawlerUrlTracingResultRequest, options?: TransportRequestOptions): Promise<T.GetCrawlerUrlTracingResultResponse> {
    const {
      engine_name,
      body,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.GetCrawlerUrlTracingResultResponse>({
      method: 'POST',
      path: `/api/as/v1/engines/${engine_name}/crawler/trace_url`,
      querystring,
      body: body
    }, options)
  }

  async getCrawlerUrlValidationResult (this: That, params: T.GetCrawlerUrlValidationResultRequest, options?: TransportRequestOptions): Promise<T.GetCrawlerUrlValidationResultResponse> {
    const {
      engine_name,
      body,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.GetCrawlerUrlValidationResultResponse>({
      method: 'POST',
      path: `/api/as/v1/engines/${engine_name}/crawler/validate_url`,
      querystring,
      body: body
    }, options)
  }

  async getCrawlerDomainValidationResult (this: That, params: T.GetCrawlerDomainValidationResultRequest, options?: TransportRequestOptions): Promise<T.GetCrawlerDomainValidationResultResponse> {
    const {
      body,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.GetCrawlerDomainValidationResultResponse>({
      method: 'POST',
      path: '/api/as/v1/crawler/validate_url',
      querystring,
      body: body
    }, options)
  }

  async getCrawlerUserAgent (this: That, params?: T.GetCrawlerUserAgentRequest, options?: TransportRequestOptions): Promise<T.GetCrawlerUserAgentResponse> {
    return await this.transport.request<T.GetCrawlerUserAgentResponse>({
      method: 'GET',
      path: '/api/as/v1/crawler/user_agent'
    }, options)
  }

  async listApiKeys (this: That, params?: T.ListApiKeysRequest, options?: TransportRequestOptions): Promise<T.ListApiKeysResponse> {
    const {
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.ListApiKeysResponse>({
      method: 'GET',
      path: '/api/as/v1/credentials',
      querystring
    }, options)
  }

  async createApiKey (this: That, params?: T.CreateApiKeyRequest, options?: TransportRequestOptions): Promise<T.CreateApiKeyResponse> {
    const {
      body,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.CreateApiKeyResponse>({
      method: 'POST',
      path: '/api/as/v1/credentials',
      querystring,
      body: body
    }, options)
  }

  async getApiKey (this: That, params: T.GetApiKeyRequest, options?: TransportRequestOptions): Promise<T.GetApiKeyResponse> {
    const {
      api_key_name,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.GetApiKeyResponse>({
      method: 'GET',
      path: `/api/as/v1/credentials/${api_key_name}`,
      querystring
    }, options)
  }

  async putApiKey (this: That, params: T.PutApiKeyRequest, options?: TransportRequestOptions): Promise<T.PutApiKeyResponse> {
    const {
      api_key_name,
      body,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.PutApiKeyResponse>({
      method: 'PUT',
      path: `/api/as/v1/credentials/${api_key_name}`,
      querystring,
      body: body
    }, options)
  }

  async deleteApiKey (this: That, params: T.DeleteApiKeyRequest, options?: TransportRequestOptions): Promise<T.DeleteApiKeyResponse> {
    const {
      api_key_name,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.DeleteApiKeyResponse>({
      method: 'DELETE',
      path: `/api/as/v1/credentials/${api_key_name}`,
      querystring
    }, options)
  }

  async listCurations (this: That, params: T.ListCurationsRequest, options?: TransportRequestOptions): Promise<T.ListCurationsResponse> {
    const {
      engine_name,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.ListCurationsResponse>({
      method: 'GET',
      path: `/api/as/v1/engines/${engine_name}/curations`,
      querystring
    }, options)
  }

  async createCuration (this: That, params: T.CreateCurationRequest, options?: TransportRequestOptions): Promise<T.CreateCurationResponse> {
    const {
      engine_name,
      body,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.CreateCurationResponse>({
      method: 'POST',
      path: `/api/as/v1/engines/${engine_name}/curations`,
      querystring,
      body: body
    }, options)
  }

  async getCuration (this: That, params: T.GetCurationRequest, options?: TransportRequestOptions): Promise<T.GetCurationResponse> {
    const {
      engine_name,
      curation_id,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.GetCurationResponse>({
      method: 'GET',
      path: `/api/as/v1/engines/${engine_name}/curations/${curation_id}`,
      querystring
    }, options)
  }

  async putCuration (this: That, params: T.PutCurationRequest, options?: TransportRequestOptions): Promise<T.PutCurationResponse> {
    const {
      engine_name,
      curation_id,
      body,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.PutCurationResponse>({
      method: 'PUT',
      path: `/api/as/v1/engines/${engine_name}/curations/${curation_id}`,
      querystring,
      body: body
    }, options)
  }

  async deleteCuration (this: That, params: T.DeleteCurationRequest, options?: TransportRequestOptions): Promise<T.DeleteCurationResponse> {
    const {
      engine_name,
      curation_id,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.DeleteCurationResponse>({
      method: 'DELETE',
      path: `/api/as/v1/engines/${engine_name}/curations/${curation_id}`,
      querystring
    }, options)
  }

  async getDocuments (this: That, params: T.GetDocumentsRequest, options?: TransportRequestOptions): Promise<T.GetDocumentsResponse> {
    const {
      engine_name,
      documentIds,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.GetDocumentsResponse>({
      method: 'GET',
      path: `/api/as/v1/engines/${engine_name}/documents`,
      querystring,
      body: documentIds
    }, options)
  }

  async indexDocuments (this: That, params: T.IndexDocumentsRequest, options?: TransportRequestOptions): Promise<T.IndexDocumentsResponse> {
    const {
      engine_name,
      documents,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.IndexDocumentsResponse>({
      method: 'POST',
      path: `/api/as/v1/engines/${engine_name}/documents`,
      querystring,
      body: documents
    }, options)
  }

  async deleteDocuments (this: That, params: T.DeleteDocumentsRequest, options?: TransportRequestOptions): Promise<T.DeleteDocumentsResponse> {
    const {
      engine_name,
      documentIds,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.DeleteDocumentsResponse>({
      method: 'DELETE',
      path: `/api/as/v1/engines/${engine_name}/documents`,
      querystring,
      body: documentIds
    }, options)
  }

  async putDocuments (this: That, params: T.PutDocumentsRequest, options?: TransportRequestOptions): Promise<T.PutDocumentsResponse> {
    const {
      engine_name,
      documents,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.PutDocumentsResponse>({
      method: 'PATCH',
      path: `/api/as/v1/engines/${engine_name}/documents`,
      querystring,
      body: documents
    }, options)
  }

  async listDocuments (this: That, params: T.ListDocumentsRequest, options?: TransportRequestOptions): Promise<T.ListDocumentsResponse> {
    const {
      engine_name,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.ListDocumentsResponse>({
      method: 'GET',
      path: `/api/as/v1/engines/${engine_name}/documents/list`,
      querystring
    }, options)
  }

  async listEngines (this: That, params?: T.ListEnginesRequest, options?: TransportRequestOptions): Promise<T.ListEnginesResponse> {
    const {
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.ListEnginesResponse>({
      method: 'GET',
      path: '/api/as/v1/engines',
      querystring
    }, options)
  }

  async createEngine (this: That, params?: T.CreateEngineRequest, options?: TransportRequestOptions): Promise<T.CreateEngineResponse> {
    const {
      body,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.CreateEngineResponse>({
      method: 'POST',
      path: '/api/as/v1/engines',
      querystring,
      body: body
    }, options)
  }

  async getEngine (this: That, params: T.GetEngineRequest, options?: TransportRequestOptions): Promise<T.GetEngineResponse> {
    const {
      engine_name,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.GetEngineResponse>({
      method: 'GET',
      path: `/api/as/v1/engines/${engine_name}`,
      querystring
    }, options)
  }

  async deleteEngine (this: That, params: T.DeleteEngineRequest, options?: TransportRequestOptions): Promise<T.DeleteEngineResponse> {
    const {
      engine_name,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.DeleteEngineResponse>({
      method: 'DELETE',
      path: `/api/as/v1/engines/${engine_name}`,
      querystring
    }, options)
  }

  async deleteMetaEngineSource (this: That, params: T.DeleteMetaEngineSourceRequest, options?: TransportRequestOptions): Promise<T.DeleteMetaEngineSourceResponse> {
    const {
      engine_name,
      sourceEngines,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.DeleteMetaEngineSourceResponse>({
      method: 'DELETE',
      path: `/api/as/v1/engines/${engine_name}/source_engines`,
      querystring,
      body: sourceEngines
    }, options)
  }

  async addMetaEngineSource (this: That, params: T.AddMetaEngineSourceRequest, options?: TransportRequestOptions): Promise<T.AddMetaEngineSourceResponse> {
    const {
      engine_name,
      sourceEngines,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.AddMetaEngineSourceResponse>({
      method: 'POST',
      path: `/api/as/v1/engines/${engine_name}/source_engines`,
      querystring,
      body: sourceEngines
    }, options)
  }

  async searchEsSearch (this: That, params: T.SearchEsSearchRequest, options?: TransportRequestOptions): Promise<T.SearchEsSearchResponse> {
    const {
      engine_name,
      body,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.SearchEsSearchResponse>({
      method: 'POST',
      path: `/api/as/v1/engines/${engine_name}/elasticsearch/_search`,
      querystring,
      body: body
    }, options)
  }

  async getApiLogs (this: That, params: T.GetApiLogsRequest, options?: TransportRequestOptions): Promise<T.GetApiLogsResponse> {
    const {
      engine_name,
      body,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.GetApiLogsResponse>({
      method: 'POST',
      path: `/api/as/v1/engines/${engine_name}/logs/api`,
      querystring,
      body: body
    }, options)
  }

  async querySuggestion (this: That, params: T.QuerySuggestionRequest, options?: TransportRequestOptions): Promise<T.QuerySuggestionResponse> {
    const {
      engine_name,
      body,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.QuerySuggestionResponse>({
      method: 'POST',
      path: `/api/as/v1/engines/${engine_name}/query_suggestion`,
      querystring,
      body: body
    }, options)
  }

  async getSchema (this: That, params: T.GetSchemaRequest, options?: TransportRequestOptions): Promise<T.GetSchemaResponse> {
    const {
      engine_name,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.GetSchemaResponse>({
      method: 'GET',
      path: `/api/as/v1/engines/${engine_name}/schema`,
      querystring
    }, options)
  }

  async putSchema (this: That, params: T.PutSchemaRequest, options?: TransportRequestOptions): Promise<T.PutSchemaResponse> {
    const {
      engine_name,
      schema,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.PutSchemaResponse>({
      method: 'POST',
      path: `/api/as/v1/engines/${engine_name}/schema`,
      querystring,
      body: schema
    }, options)
  }

  async search (this: That, params: T.SearchRequest, options?: TransportRequestOptions): Promise<T.SearchResponse> {
    const {
      engine_name,
      body,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.SearchResponse>({
      method: 'POST',
      path: `/api/as/v1/engines/${engine_name}/search`,
      querystring,
      body: body
    }, options)
  }

  async multiSearch (this: That, params: T.MultiSearchRequest, options?: TransportRequestOptions): Promise<T.MultiSearchResponse> {
    const {
      engine_name,
      body,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.MultiSearchResponse>({
      method: 'POST',
      path: `/api/as/v1/engines/${engine_name}/multi_search`,
      querystring,
      body: body
    }, options)
  }

  async search_explain (this: That, params: T.SearchExplainRequest, options?: TransportRequestOptions): Promise<T.SearchExplainResponse> {
    const {
      engine_name,
      body,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.SearchExplainResponse>({
      method: 'POST',
      path: `/api/as/v1/engines/${engine_name}/search_explain`,
      querystring,
      body: body
    }, options)
  }

  async getSearchSettings (this: That, params: T.GetSearchSettingsRequest, options?: TransportRequestOptions): Promise<T.GetSearchSettingsResponse> {
    const {
      engine_name,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.GetSearchSettingsResponse>({
      method: 'GET',
      path: `/api/as/v1/engines/${engine_name}/search_settings`,
      querystring
    }, options)
  }

  async putSearchSettings (this: That, params: T.PutSearchSettingsRequest, options?: TransportRequestOptions): Promise<T.PutSearchSettingsResponse> {
    const {
      engine_name,
      body,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.PutSearchSettingsResponse>({
      method: 'PUT',
      path: `/api/as/v1/engines/${engine_name}/search_settings`,
      querystring,
      body: body
    }, options)
  }

  async resetSearchSettings (this: That, params: T.ResetSearchSettingsRequest, options?: TransportRequestOptions): Promise<T.ResetSearchSettingsResponse> {
    const {
      engine_name,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.ResetSearchSettingsResponse>({
      method: 'POST',
      path: `/api/as/v1/engines/${engine_name}/search_settings/reset`,
      querystring
    }, options)
  }

  async listSynonymSets (this: That, params: T.ListSynonymSetsRequest, options?: TransportRequestOptions): Promise<T.ListSynonymSetsResponse> {
    const {
      engine_name,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.ListSynonymSetsResponse>({
      method: 'GET',
      path: `/api/as/v1/engines/${engine_name}/synonyms`,
      querystring
    }, options)
  }

  async createSynonymSet (this: That, params: T.CreateSynonymSetRequest, options?: TransportRequestOptions): Promise<T.CreateSynonymSetResponse> {
    const {
      engine_name,
      body,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.CreateSynonymSetResponse>({
      method: 'POST',
      path: `/api/as/v1/engines/${engine_name}/synonyms`,
      querystring,
      body: body
    }, options)
  }

  async getSynonymSet (this: That, params: T.GetSynonymSetRequest, options?: TransportRequestOptions): Promise<T.GetSynonymSetResponse> {
    const {
      engine_name,
      synonym_set_id,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.GetSynonymSetResponse>({
      method: 'GET',
      path: `/api/as/v1/engines/${engine_name}/synonyms/${synonym_set_id}`,
      querystring
    }, options)
  }

  async putSynonymSet (this: That, params: T.PutSynonymSetRequest, options?: TransportRequestOptions): Promise<T.PutSynonymSetResponse> {
    const {
      engine_name,
      synonym_set_id,
      body,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.PutSynonymSetResponse>({
      method: 'PUT',
      path: `/api/as/v1/engines/${engine_name}/synonyms/${synonym_set_id}`,
      querystring,
      body: body
    }, options)
  }

  async deleteSynonymSet (this: That, params: T.DeleteSynonymSetRequest, options?: TransportRequestOptions): Promise<T.DeleteSynonymSetResponse> {
    const {
      engine_name,
      synonym_set_id,
      ...querystring
    } = params ?? {}
    return await this.transport.request<T.DeleteSynonymSetResponse>({
      method: 'DELETE',
      path: `/api/as/v1/engines/${engine_name}/synonyms/${synonym_set_id}`,
      querystring
    }, options)
  }
}