Elasticsearch JavaScript Client

import { Client } from "@elastic/elasticsearch";

const { Client } = require("@elastic/elasticsearch");

import { 
  Client, 
  SniffingTransport,
  errors,
  estypes,
  helpers,
  type ClientOptions,
  type NodeOptions
} from "@elastic/elasticsearch";

import {
  Client,
  SniffingTransport,
  Diagnostic,
  Transport,
  WeightedConnectionPool,
  ClusterConnectionPool,
  BaseConnectionPool,
  CloudConnectionPool,
  BaseConnection,
  HttpConnection,
  UndiciConnection,
  Serializer,
  events
} from "@elastic/elasticsearch";

// Core client and types
import { Client, SniffingTransport } from "@elastic/elasticsearch";
import type { ClientOptions, NodeOptions } from "@elastic/elasticsearch";

// All types (re-exported from @elastic/transport)
import * as estypes from "@elastic/elasticsearch";

// Helper functions
import { helpers } from "@elastic/elasticsearch";

// Transport layer components
import {
  Diagnostic,
  Transport,
  WeightedConnectionPool,
  ClusterConnectionPool,
  BaseConnectionPool,
  CloudConnectionPool,
  BaseConnection,
  HttpConnection,
  UndiciConnection,
  Serializer,
  errors,
  events
} from "@elastic/elasticsearch";

import { Client } from "@elastic/elasticsearch";

// Basic client connection
const client = new Client({ 
  node: "https://localhost:9200",
  auth: {
    username: "elastic",
    password: "password"
  }
});

// Document operations
await client.index({
  index: "my-index",
  id: "1",
  document: { title: "Hello World", content: "This is a test document" }
});

const response = await client.get({
  index: "my-index",
  id: "1"
});

// Search documents
const searchResult = await client.search({
  index: "my-index",
  query: { match: { title: "Hello" } }
});

class Client extends API {
  constructor(opts: ClientOptions);
  child(opts: ClientOptions): Client;
  close(): Promise<void>;
  
  // Properties
  diagnostic: Diagnostic;
  name: string | symbol;
  connectionPool: BaseConnectionPool;
  transport: SniffingTransport;
  serializer: Serializer;
  helpers: Helpers;
}

interface ClientOptions {
  /** Elasticsearch node settings, if there is only one node */
  node?: string | string[] | NodeOptions | NodeOptions[];
  /** Elasticsearch node settings, if there are multiple nodes */
  nodes?: string | string[] | NodeOptions | NodeOptions[];
  /** HTTP connection class to use */
  Connection?: typeof BaseConnection;
  /** HTTP connection pool class to use */
  ConnectionPool?: typeof BaseConnectionPool;
  /** Elastic transport class to use */
  Transport?: typeof Transport;
  /** Serialization class to use */
  Serializer?: typeof Serializer;
  /** Max number of retries for each request */
  maxRetries?: number;
  /** Max request timeout in milliseconds for each request */
  requestTimeout?: number;
  /** Max number of milliseconds a ClusterConnectionPool will wait when pinging nodes */
  pingTimeout?: number;
  /** Perform a sniff operation every n milliseconds */
  sniffInterval?: number | boolean;
  /** Perform a sniff once the client is started */
  sniffOnStart?: boolean;
  /** Endpoint to ping during a sniff */
  sniffEndpoint?: string;
  /** Perform a sniff on connection fault */
  sniffOnConnectionFault?: boolean;
  /** Strategy for resurrecting dead nodes */
  resurrectStrategy?: 'ping' | 'optimistic' | 'none';
  /** Enables gzip request body compression */
  compression?: boolean;
  /** TLS configuration */
  tls?: TlsConnectionOptions;
  /** Custom HTTP agent options */
  agent?: HttpAgentOptions | UndiciAgentOptions | agentFn | false;
  /** Custom function to determine which nodes are qualified to receive a request */
  nodeFilter?: nodeFilterFn;
  /** Custom function to determine which node should receive the next request */
  nodeSelector?: nodeSelectorFn;
  /** Custom HTTP headers that should be sent with each request */
  headers?: Record<string, any>;
  /** A string prefix to apply to every generated X-Opaque-Id header */
  opaqueIdPrefix?: string;
  /** Custom function for generating unique IDs for each request */
  generateRequestId?: generateRequestIdFn;
  /** A name for this client */
  name?: string | symbol;
  /** Authentication options for this Elasticsearch cluster */
  auth?: BasicAuth | ApiKeyAuth | BearerAuth;
  /** Custom object attached to each request for passing data to client events */
  context?: Context;
  /** Proxy URL that the client will send all requests through */
  proxy?: string | URL;
  /** If true, adds x-elastic-client-meta header with client telemetry data */
  enableMetaHeader?: boolean;
  /** Custom configuration for connecting to Elastic Cloud */
  cloud?: { id: string };
  /** Disables safe JSON parsing that protects against prototype poisoning attacks */
  disablePrototypePoisoningProtection?: boolean | 'proto' | 'constructor';
  /** CA certificate fingerprint for SSL verification */
  caFingerprint?: string;
  /** Maximum uncompressed response size in bytes */
  maxResponseSize?: number;
  /** Maximum compressed response size in bytes */
  maxCompressedResponseSize?: number;
  /** Options for redacting sensitive data from Error objects */
  redaction?: RedactionOptions;
  /** Server mode setting - "stack" for traditional ES, "serverless" for Elastic Cloud Serverless */
  serverMode?: 'stack' | 'serverless';
}

// Single document operations
function index(params: {
  index: IndexName;
  id?: Id;
  document: TDocument;
  refresh?: Refresh;
  routing?: Routing;
}): Promise<TransportResult<IndexResponse, unknown>>;

function get(params: {
  index: IndexName;
  id: Id;
  _source?: boolean | Fields;
  routing?: Routing;
}): Promise<TransportResult<GetResponse<TDocument>, unknown>>;

function update(params: {
  index: IndexName;
  id: Id;
  doc?: Partial<TDocument>;
  script?: Script;
  refresh?: Refresh;
}): Promise<TransportResult<UpdateResponse<TDocument>, unknown>>;

function delete(params: {
  index: IndexName;
  id: Id;
  refresh?: Refresh;
  routing?: Routing;
}): Promise<TransportResult<DeleteResponse, unknown>>;

// Bulk operations
function bulk(params: {
  index?: IndexName;
  operations: BulkOperationContainer[];
  refresh?: Refresh;
}): Promise<TransportResult<BulkResponse, unknown>>;

function search<TDocument = unknown, TAggregations = Record<AggregateName, AggregationsAggregate>>(params: {
  index?: Indices;
  query?: QueryDslQueryContainer;
  aggs?: Record<string, AggregationsAggregationContainer>;
  sort?: SortCombinations[];
  _source?: boolean | Fields;
  from?: number;
  size?: number;
  highlight?: SearchHighlight;
  track_total_hits?: boolean | number;
}): Promise<TransportResult<SearchResponse<TDocument, TAggregations>, unknown>>;

function msearch(params: {
  searches: MsearchMultisearchBody[];
  index?: Indices;
}): Promise<TransportResult<MsearchResponse, unknown>>;

function scroll(params: {
  scroll_id: ScrollId;
  scroll?: Duration;
}): Promise<TransportResult<ScrollResponse<TDocument>, unknown>>;

namespace indices {
  function create(params: {
    index: IndexName;
    aliases?: Record<IndexName, IndicesAlias>;
    mappings?: MappingTypeMapping;
    settings?: IndicesIndexSettings;
  }): Promise<TransportResult<IndicesCreateResponse, unknown>>;

  function putMapping(params: {
    index: Indices;
    properties?: Record<PropertyName, MappingProperty>;
    dynamic?: MappingDynamicMapping;
  }): Promise<TransportResult<IndicesputMappingResponse, unknown>>;
  
  function putSettings(params: {
    index: Indices;
    settings: IndicesIndexSettings;
  }): Promise<TransportResult<IndicesputSettingsResponse, unknown>>;
}

namespace cluster {
  function health(params?: {
    index?: Indices;
    level?: Level;
    wait_for_status?: HealthStatus;
    timeout?: Duration;
  }): Promise<TransportResult<ClusterHealthResponse, unknown>>;

  function stats(params?: {
    node_id?: NodeIds;
    flat_settings?: boolean;
    timeout?: Duration;
  }): Promise<TransportResult<ClusterStatsResponse, unknown>>;

  function putSettings(params: {
    persistent?: Record<string, any>;
    transient?: Record<string, any>;
  }): Promise<TransportResult<ClusterPutSettingsResponse, unknown>>;
}

namespace ml {
  function putJob(params: {
    job_id: Id;
    analysis_config: MlAnalysisConfig;
    data_description: MlDataDescription;
    description?: string;
  }): Promise<TransportResult<MlPutJobResponse, unknown>>;

  function putTrainedModel(params: {
    model_id: Id;
    compressed_definition?: string;
    inference_config?: MlInferenceConfigContainer;
    input: MlTrainedModelConfigInput;
  }): Promise<TransportResult<MlPutTrainedModelResponse, unknown>>;
}

namespace security {
  function putUser(params: {
    username: Username;
    password?: Password;
    roles: string[];
    full_name?: string;
    email?: string;
  }): Promise<TransportResult<SecurityPutUserResponse, unknown>>;

  function createApiKey(params: {
    name: Name;
    role_descriptors?: Record<string, SecurityRoleDescriptor>;
    expiration?: Duration;
  }): Promise<TransportResult<SecurityCreateApiKeyResponse, unknown>>;
}

interface Helpers {
  search<TDocument>(
    params: SearchRequest,
    options?: TransportRequestOptions
  ): Promise<Array<TDocument & { _id: Id }>>;

  scrollSearch<TDocument>(
    params: SearchRequest,
    options?: ScrollSearchOptions
  ): AsyncIterable<ScrollSearchResponse<TDocument>>;

  bulk<TDocument>(
    params: BulkHelperOptions<TDocument>,
    options?: TransportRequestOptions
  ): BulkHelper<TDocument>;

  msearch(
    params: MsearchHelperOptions,
    options?: TransportRequestOptions
  ): MsearchHelper;
}

namespace cat {
  function health(params?: {
    format?: string;
    h?: string[];
    v?: boolean;
  }): Promise<TransportResult<CatHealthRecord[], unknown>>;

  function indices(params?: {
    index?: Indices;
    format?: string;
    h?: string[];
    bytes?: Bytes;
  }): Promise<TransportResult<CatIndicesRecord[], unknown>>;

  function nodes(params?: {
    format?: string;
    h?: string[];
    full_id?: boolean;
  }): Promise<TransportResult<CatNodesRecord[], unknown>>;
}

// Snapshot operations
namespace snapshot {
  function create(params: {
    repository: Name;
    snapshot: Name;
    indices?: Indices;
    wait_for_completion?: boolean;
  }): Promise<TransportResult<SnapshotCreateResponse, unknown>>;
}

// Data transformation
namespace transform {
  function putTransform(params: {
    transform_id: Id;
    source: TransformSource;
    dest: TransformDestination;
    pivot?: TransformPivot;
  }): Promise<TransportResult<TransformPutTransformResponse, unknown>>;
}

type IndexName = string;
type Id = string | number;
type Routing = string;
type Refresh = boolean | 'wait_for' | 'false' | 'true';
type Duration = string; // e.g., "1m", "30s", "2h"

interface BasicAuth {
  username: string;
  password: string;
}

interface ApiKeyAuth {
  id: string;
  api_key: string;
}

interface BearerAuth {
  bearer: string;
}

interface TransportResult<TResponse, TContext> {
  body: TResponse;
  statusCode: number;
  headers: Record<string, string | string[]>;
  warnings: string[];
  meta: {
    context: TContext;
    name: string;
    request: { params: TransportRequestParams; options: TransportRequestOptions };
    connection: Connection;
    attempts: number;
    aborted: boolean;
  };
}

interface SearchResponse<TDocument = unknown, TAggregations = Record<AggregateName, AggregationsAggregate>> {
  took: number;
  timed_out: boolean;
  _shards: ShardStatistics;
  hits: SearchHitsMetadata<TDocument>;
  aggregations?: TAggregations;
}

import { errors } from "@elastic/elasticsearch";

try {
  await client.get({ index: "my-index", id: "1" });
} catch (error) {
  if (error instanceof errors.ResponseError) {
    console.log("Elasticsearch error:", error.body);
  } else if (error instanceof errors.ConnectionError) {
    console.log("Connection error:", error.message);
  } else if (error instanceof errors.TimeoutError) {
    console.log("Request timeout:", error.message);
  }
}