ts-prorm-orm 1.1.0 → 1.2.1

package/dist/nosql/dynamodb/index.js

@@ -77,6 +77,167 @@ class DynamoDbError extends errors_1.DatabaseError {
     }
 }
 exports.DynamoDbError = DynamoDbError;
+/** Parse an ORM `where` object (string + `Op` symbol keys) into a tree. */
+function parseWhere(where) {
+    if (!where || typeof where !== 'object')
+        return null;
+    const nodes = [];
+    for (const sym of Object.getOwnPropertySymbols(where)) {
+        const name = sym.description;
+        const val = where[sym];
+        if (name === 'and' && Array.isArray(val)) {
+            nodes.push({ kind: 'and', nodes: val.map(parseWhere).filter(Boolean) });
+        }
+        else if (name === 'or' && Array.isArray(val)) {
+            nodes.push({ kind: 'or', nodes: val.map(parseWhere).filter(Boolean) });
+        }
+        else if (name === 'not') {
+            const inner = parseWhere(val);
+            if (inner)
+                nodes.push({ kind: 'not', node: inner });
+        }
+    }
+    for (const field of Object.keys(where)) {
+        nodes.push(parseFieldCondition(field, where[field]));
+    }
+    const flat = nodes.filter(Boolean);
+    if (flat.length === 0)
+        return null;
+    return flat.length === 1 ? flat[0] : { kind: 'and', nodes: flat };
+}
+/** Parse the value for a single field into a comparison (or AND of them). */
+function parseFieldCondition(field, value) {
+    if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+        const symbols = Object.getOwnPropertySymbols(value);
+        if (symbols.length > 0) {
+            const cmps = symbols.map((sym) => ({
+                kind: 'cmp',
+                field,
+                op: sym.description ?? 'eq',
+                value: value[sym],
+            }));
+            return cmps.length === 1 ? cmps[0] : { kind: 'and', nodes: cmps };
+        }
+    }
+    return { kind: 'cmp', field, op: value === null ? 'isNull' : 'eq', value };
+}
+/** Collect the top-level AND leaf comparisons of a tree (for key extraction). */
+function topLevelLeaves(node) {
+    if (!node)
+        return [];
+    if (node.kind === 'cmp')
+        return [node];
+    if (node.kind === 'and')
+        return node.nodes.flatMap(topLevelLeaves);
+    return [];
+}
+/** Sort-key operators that DynamoDB permits in a KeyConditionExpression. */
+const SORT_KEY_OPS = new Set(['eq', 'gt', 'gte', 'lt', 'lte', 'between', 'startsWith']);
+/**
+ * Incrementally builds DynamoDB expression strings while allocating collision-
+ * free `#name`/`:value` placeholders (so reserved words and nested paths are
+ * always safe).
+ */
+class DynamoExprBuilder {
+    constructor() {
+        this.names = {};
+        this.values = {};
+        this.n = 0;
+        this.v = 0;
+    }
+    /** Allocate placeholders for a (possibly dotted) attribute path. */
+    path(field) {
+        return field
+            .split('.')
+            .map((part) => {
+            const key = `#n${this.n++}`;
+            this.names[key] = part;
+            return key;
+        })
+            .join('.');
+    }
+    /** Allocate a value placeholder. */
+    val(value) {
+        const key = `:v${this.v++}`;
+        this.values[key] = value;
+        return key;
+    }
+    /** Render a comparison to a FilterExpression/KeyConditionExpression fragment. */
+    cmp(field, op, value) {
+        const p = this.path(field);
+        switch (op) {
+            case 'eq':
+                return value === null ? `attribute_not_exists(${p})` : `${p} = ${this.val(value)}`;
+            case 'ne':
+                return `${p} <> ${this.val(value)}`;
+            case 'gt':
+                return `${p} > ${this.val(value)}`;
+            case 'gte':
+                return `${p} >= ${this.val(value)}`;
+            case 'lt':
+                return `${p} < ${this.val(value)}`;
+            case 'lte':
+                return `${p} <= ${this.val(value)}`;
+            case 'between': {
+                const [a, b] = value;
+                return `${p} BETWEEN ${this.val(a)} AND ${this.val(b)}`;
+            }
+            case 'notBetween': {
+                const [a, b] = value;
+                return `NOT (${p} BETWEEN ${this.val(a)} AND ${this.val(b)})`;
+            }
+            case 'in': {
+                const arr = value ?? [];
+                if (arr.length === 0)
+                    return 'attribute_not_exists(nonexistent_placeholder_attr)';
+                return `${p} IN (${arr.map((x) => this.val(x)).join(', ')})`;
+            }
+            case 'notIn': {
+                const arr = value ?? [];
+                if (arr.length === 0)
+                    return 'attribute_exists(' + p + ') OR attribute_not_exists(' + p + ')';
+                return `NOT (${p} IN (${arr.map((x) => this.val(x)).join(', ')}))`;
+            }
+            case 'startsWith':
+                return `begins_with(${p}, ${this.val(String(value))})`;
+            case 'substring':
+                return `contains(${p}, ${this.val(value)})`;
+            case 'notSubstring':
+                return `NOT contains(${p}, ${this.val(value)})`;
+            case 'contains':
+            case 'arrayContains':
+                return `contains(${p}, ${this.val(Array.isArray(value) ? value[0] : value)})`;
+            case 'like': {
+                // Only the simple begins_with / contains LIKE shapes are expressible.
+                const s = String(value);
+                if (/^[^%_]+%$/.test(s))
+                    return `begins_with(${p}, ${this.val(s.slice(0, -1))})`;
+                if (/^%[^%_]+%$/.test(s))
+                    return `contains(${p}, ${this.val(s.slice(1, -1))})`;
+                throw new errors_1.DatabaseError(`DynamoDB ORM layer can only translate LIKE patterns of the form 'x%' or '%x%' (got ${JSON.stringify(s)})`, { code: 'QUERY_ERROR' });
+            }
+            case 'isNull':
+                return `attribute_not_exists(${p})`;
+            case 'isNotNull':
+                return `attribute_exists(${p})`;
+            default:
+                throw new errors_1.DatabaseError(`DynamoDB ORM layer does not support operator "${op}" for attribute "${field}"`, { code: 'QUERY_ERROR' });
+        }
+    }
+    /** Render an arbitrary boolean tree to a FilterExpression string. */
+    filter(node) {
+        switch (node.kind) {
+            case 'and':
+                return node.nodes.length ? `(${node.nodes.map((n) => this.filter(n)).join(' AND ')})` : '';
+            case 'or':
+                return node.nodes.length ? `(${node.nodes.map((n) => this.filter(n)).join(' OR ')})` : '';
+            case 'not':
+                return `NOT (${this.filter(node.node)})`;
+            case 'cmp':
+                return this.cmp(node.field, node.op, node.value);
+        }
+    }
+}
 /**
  * Amazon DynamoDB store, implementing the minimal `NoSqlStore` marker
  * interface. Unlike the SQL dialects, there is no `query(sql)` — DynamoDB's
@@ -933,5 +1094,267 @@ class DynamoDbStore {
             throw this.wrapError(`ListTagsOfResource on '${resourceArn}'`, err);
         }
     }
+    // ---------------------------------------------------------------------
+    // ORM model surface (no hand-written Key/Filter expressions needed)
+    // ---------------------------------------------------------------------
+    /**
+     * Compile an ORM `where` clause + read options into either a `QueryParams`
+     * (when the partition key is pinned by equality, so DynamoDB can Query) or a
+     * `ScanParams` (otherwise). Shared by {@link findAll}/{@link findAllPaged}/
+     * {@link count}.
+     */
+    compileRead(options) {
+        const node = parseWhere(options.where);
+        const schema = options.indexName ? options.key?.indexes?.[options.indexName] : options.key;
+        const leaves = topLevelLeaves(node).filter((l) => l.kind === 'cmp');
+        const pkLeaf = schema
+            ? leaves.find((l) => l.field === schema.partitionKey && l.op === 'eq')
+            : undefined;
+        const skLeaf = pkLeaf && schema?.sortKey
+            ? leaves.find((l) => l.field === schema.sortKey && SORT_KEY_OPS.has(l.op))
+            : undefined;
+        const builder = new DynamoExprBuilder();
+        const projectionExpression = options.attributes && options.attributes.length > 0
+            ? options.attributes.map((a) => builder.path(a)).join(', ')
+            : undefined;
+        if (pkLeaf) {
+            const keyParts = [builder.cmp(pkLeaf.field, 'eq', pkLeaf.value)];
+            if (skLeaf)
+                keyParts.push(builder.cmp(skLeaf.field, skLeaf.op, skLeaf.value));
+            const filterLeaves = leaves.filter((l) => l !== pkLeaf && l !== skLeaf);
+            const filterExpression = filterLeaves.length
+                ? filterLeaves.map((l) => builder.filter(l)).join(' AND ')
+                : undefined;
+            return {
+                mode: 'query',
+                params: {
+                    indexName: options.indexName,
+                    keyConditionExpression: keyParts.join(' AND '),
+                    filterExpression,
+                    projectionExpression,
+                    expressionAttributeNames: Object.keys(builder.names).length ? builder.names : undefined,
+                    expressionAttributeValues: Object.keys(builder.values).length
+                        ? builder.values
+                        : undefined,
+                    limit: options.limit,
+                    scanIndexForward: options.order ? options.order !== 'DESC' : undefined,
+                    exclusiveStartKey: options.exclusiveStartKey,
+                    consistentRead: options.consistentRead,
+                },
+            };
+        }
+        const filterExpression = node ? builder.filter(node) || undefined : undefined;
+        return {
+            mode: 'scan',
+            params: {
+                indexName: options.indexName,
+                filterExpression,
+                projectionExpression,
+                expressionAttributeNames: Object.keys(builder.names).length ? builder.names : undefined,
+                expressionAttributeValues: Object.keys(builder.values).length ? builder.values : undefined,
+                limit: options.limit,
+                exclusiveStartKey: options.exclusiveStartKey,
+                consistentRead: options.consistentRead,
+            },
+        };
+    }
+    /**
+     * Fetch items matching the ORM `where` clause. When `options.key` pins the
+     * partition key by equality this issues an efficient `Query`; otherwise it
+     * falls back to a `Scan` (see the warning on {@link scan}). Returns a single
+     * page plus the `lastEvaluatedKey` cursor (pass it back as
+     * `exclusiveStartKey` for the next page, or use {@link findAll} to
+     * auto-paginate).
+     */
+    async findAllPaged(tableName, options = {}) {
+        const compiled = this.compileRead(options);
+        return compiled.mode === 'query'
+            ? this.query(tableName, compiled.params)
+            : this.scan(tableName, compiled.params);
+    }
+    /**
+     * Auto-paginating {@link findAllPaged}: follows `lastEvaluatedKey` and
+     * returns every matching item. `options.limit` still applies per page (as
+     * DynamoDB defines it); to cap total results, slice the return value.
+     */
+    async findAll(tableName, options = {}) {
+        const items = [];
+        let exclusiveStartKey = options.exclusiveStartKey;
+        do {
+            const page = await this.findAllPaged(tableName, { ...options, exclusiveStartKey });
+            items.push(...page.items);
+            exclusiveStartKey = page.lastEvaluatedKey;
+        } while (exclusiveStartKey !== undefined);
+        return items;
+    }
+    /** Fetch the first item matching `where` (page-limited to 1), or `undefined`. */
+    async findOne(tableName, options = {}) {
+        const page = await this.findAllPaged(tableName, { ...options, limit: 1 });
+        return page.items[0];
+    }
+    /**
+     * Count items matching `where` using `Select: 'COUNT'` (server-side count;
+     * items are not returned). Follows pagination automatically and sums each
+     * page's count.
+     */
+    async count(tableName, options = {}) {
+        const client = this.requireClient();
+        const compiled = this.compileRead(options);
+        let total = 0;
+        let exclusiveStartKey = compiled.params.exclusiveStartKey;
+        try {
+            do {
+                if (compiled.mode === 'query') {
+                    const p = compiled.params;
+                    const result = await client.send(new lib_dynamodb_1.QueryCommand({
+                        TableName: tableName,
+                        IndexName: p.indexName,
+                        KeyConditionExpression: p.keyConditionExpression,
+                        FilterExpression: p.filterExpression,
+                        ExpressionAttributeNames: p.expressionAttributeNames,
+                        ExpressionAttributeValues: p.expressionAttributeValues,
+                        ConsistentRead: p.consistentRead,
+                        Select: 'COUNT',
+                        ExclusiveStartKey: exclusiveStartKey,
+                    }));
+                    total += result.Count ?? 0;
+                    exclusiveStartKey = result.LastEvaluatedKey;
+                }
+                else {
+                    const p = compiled.params;
+                    const result = await client.send(new lib_dynamodb_1.ScanCommand({
+                        TableName: tableName,
+                        IndexName: p.indexName,
+                        FilterExpression: p.filterExpression,
+                        ExpressionAttributeNames: p.expressionAttributeNames,
+                        ExpressionAttributeValues: p.expressionAttributeValues,
+                        ConsistentRead: p.consistentRead,
+                        Select: 'COUNT',
+                        ExclusiveStartKey: exclusiveStartKey,
+                    }));
+                    total += result.Count ?? 0;
+                    exclusiveStartKey = result.LastEvaluatedKey;
+                }
+            } while (exclusiveStartKey !== undefined);
+        }
+        catch (err) {
+            throw this.wrapError(`Count on '${tableName}'`, err);
+        }
+        return total;
+    }
+    /**
+     * Insert an item (`PutItem`). By default overwrites any existing item with
+     * the same key (native Put semantics); pass `options.key` with
+     * `options.insertOnly` to add an `attribute_not_exists(<pk>)` condition so a
+     * duplicate primary key fails instead (SQL `INSERT` semantics).
+     */
+    async create(tableName, item, options = {}) {
+        const putOptions = {};
+        if (options.insertOnly && options.key) {
+            putOptions.conditionExpression = 'attribute_not_exists(#pk)';
+            putOptions.expressionAttributeNames = { '#pk': options.key.partitionKey };
+        }
+        await this.putItem(tableName, item, putOptions);
+        return item;
+    }
+    /** Insert many items via chunked/retried `BatchWriteItem` puts. */
+    async bulkCreate(tableName, items, options = {}) {
+        const { unprocessedCount } = await this.batchWriteItem(tableName, items.map((put) => ({ put })), options);
+        return { inserted: items.length - unprocessedCount, unprocessedCount };
+    }
+    /**
+     * Insert-or-replace an item (`PutItem`) — DynamoDB's native Put already has
+     * upsert semantics (it creates the item or overwrites it wholesale).
+     */
+    async upsert(tableName, item) {
+        await this.putItem(tableName, item);
+        return item;
+    }
+    /** Extract a full primary key `{pk, sk?}` from top-level eq leaves, or null. */
+    extractFullKey(schema, leaves) {
+        const pk = leaves.find((l) => l.field === schema.partitionKey && l.op === 'eq');
+        if (!pk)
+            return null;
+        const key = { [schema.partitionKey]: pk.value };
+        let used = 1;
+        if (schema.sortKey) {
+            const sk = leaves.find((l) => l.field === schema.sortKey && l.op === 'eq');
+            if (!sk)
+                return null;
+            key[schema.sortKey] = sk.value;
+            used = 2;
+        }
+        // Only a "full key" if there are no *other* conditions to filter on.
+        return used === leaves.length ? key : null;
+    }
+    /**
+     * Update every item matching `where`, SETting each key in `values`. When
+     * `where` pins the full primary key (and nothing else), this is a single
+     * `UpdateItem`; otherwise it finds matching items (Query/Scan via `key`),
+     * then issues one `UpdateItem` per item. Requires `options.key`. Returns the
+     * number of items updated.
+     */
+    async update(tableName, values, where, options = { key: { partitionKey: '' } }) {
+        const schema = options.key;
+        if (!schema || !schema.partitionKey) {
+            throw new errors_1.DatabaseError('DynamoDB update() requires options.key with a partitionKey', {
+                code: 'VALIDATION_ERROR',
+            });
+        }
+        const leaves = topLevelLeaves(parseWhere(where)).filter((l) => l.kind === 'cmp');
+        const directKey = this.extractFullKey(schema, leaves);
+        if (directKey) {
+            await this.updateItem(tableName, directKey, values);
+            return 1;
+        }
+        const matches = await this.findAll(tableName, {
+            where,
+            key: schema,
+            indexName: options.indexName,
+        });
+        let updated = 0;
+        for (const item of matches) {
+            const key = this.itemKey(schema, item);
+            await this.updateItem(tableName, key, values);
+            updated += 1;
+        }
+        return updated;
+    }
+    /**
+     * Delete every item matching `where`. When `where` pins the full primary key
+     * this is a single `DeleteItem`; otherwise it finds matching items and
+     * deletes them via chunked `BatchWriteItem`. Requires `options.key`. Returns
+     * the number of items deleted.
+     */
+    async destroy(tableName, where, options = { key: { partitionKey: '' } }) {
+        const schema = options.key;
+        if (!schema || !schema.partitionKey) {
+            throw new errors_1.DatabaseError('DynamoDB destroy() requires options.key with a partitionKey', {
+                code: 'VALIDATION_ERROR',
+            });
+        }
+        const leaves = topLevelLeaves(parseWhere(where)).filter((l) => l.kind === 'cmp');
+        const directKey = this.extractFullKey(schema, leaves);
+        if (directKey) {
+            await this.deleteItem(tableName, directKey, { returnValues: 'NONE' });
+            return 1;
+        }
+        const matches = await this.findAll(tableName, {
+            where,
+            key: schema,
+            indexName: options.indexName,
+        });
+        if (matches.length === 0)
+            return 0;
+        await this.batchWriteItem(tableName, matches.map((item) => ({ delete: this.itemKey(schema, item) })));
+        return matches.length;
+    }
+    /** Project an item down to just its key attributes for the given schema. */
+    itemKey(schema, item) {
+        const key = { [schema.partitionKey]: item[schema.partitionKey] };
+        if (schema.sortKey)
+            key[schema.sortKey] = item[schema.sortKey];
+        return key;
+    }
 }
 exports.DynamoDbStore = DynamoDbStore;

package/dist/nosql/elasticsearch/index.d.ts

@@ -0,0 +1,239 @@
+/**
+ * Elasticsearch store implementation.
+ *
+ * Elasticsearch is a distributed document store built around an inverted
+ * index and a JSON-based Query DSL (`match`/`term`/`bool`/`range` queries,
+ * aggregations, sorting) rather than SQL. It has no `JOIN`, no transaction
+ * log, and documents are schema-flexible (mappings describe *how* fields
+ * are indexed, not a hard constraint like a SQL column type), so it does
+ * not fit the SQL-shaped `Dialect` interface used by the SQL dialects in
+ * this repo. Instead it implements the minimal `NoSqlStore` marker
+ * interface (`src/nosql/store.ts`) and exposes Elasticsearch's real
+ * capabilities grouped by concern: connection lifecycle, index management,
+ * document CRUD (single + bulk), search, and alias management.
+ *
+ * Uses the official `@elastic/elasticsearch` driver (v9). This client
+ * speaks the Elasticsearch REST API and is also broadly compatible with
+ * OpenSearch clusters (which forked from Elasticsearch 7.10) for the
+ * subset of the API surface wrapped here - see the README for details and
+ * caveats.
+ */
+import { Client, estypes } from '@elastic/elasticsearch';
+import type { ClientOptions } from '@elastic/elasticsearch';
+import { NoSqlStore } from '../store';
+/**
+ * Connection options for `ElasticsearchStore`. This is a thin pass-through
+ * to the driver's own `ClientOptions` (node/nodes URL(s), `auth` for
+ * basic/API-key/bearer auth, `tls`, `cloud`, `requestTimeout`,
+ * `maxRetries`, etc.) - nothing is renamed or reshaped, since the driver's
+ * options already cover connecting to a single node, a list of nodes, or
+ * Elastic Cloud.
+ */
+export type ElasticsearchStoreOptions = ClientOptions;
+/** Options accepted by `createIndex()`. */
+export interface CreateIndexOptions {
+    /** Field mappings (types, analyzers, etc.) for the new index. */
+    mappings?: estypes.MappingTypeMapping;
+    /** Index settings (shards, replicas, analysis, etc.). */
+    settings?: estypes.IndicesIndexSettings;
+    /** Aliases to create the index with. */
+    aliases?: Record<string, estypes.IndicesAlias>;
+}
+/** Options accepted by `indexDocument()`. */
+export interface IndexDocumentOptions {
+    /** `'index'` (default; overwrite) or `'create'` (fail if the ID already exists). */
+    opType?: estypes.OpType;
+    /** Refresh policy for making the write visible to search immediately. */
+    refresh?: estypes.Refresh;
+    /** Route the document to a specific shard. */
+    routing?: string;
+}
+/** Options accepted by `updateDocument()`. */
+export interface UpdateDocumentOptions {
+    /** Document to insert if it doesn't already exist (upsert). */
+    upsert?: Record<string, unknown>;
+    /** Refresh policy for making the write visible to search immediately. */
+    refresh?: estypes.Refresh;
+    /** Number of times to retry on a version conflict. */
+    retryOnConflict?: number;
+}
+/** Options accepted by `deleteDocument()`. */
+export interface DeleteDocumentOptions {
+    refresh?: estypes.Refresh;
+    routing?: string;
+}
+/** A single operation for `bulkIndex()`/`bulkDelete()`/`bulk()`. */
+export type BulkAction = {
+    action: 'index';
+    index: string;
+    id?: string;
+    document: Record<string, unknown>;
+} | {
+    action: 'create';
+    index: string;
+    id?: string;
+    document: Record<string, unknown>;
+} | {
+    action: 'update';
+    index: string;
+    id: string;
+    document: Record<string, unknown>;
+    upsert?: Record<string, unknown>;
+} | {
+    action: 'delete';
+    index: string;
+    id: string;
+};
+/** Per-item result from a `bulk()` call. */
+export interface BulkItemResult {
+    action: 'index' | 'create' | 'update' | 'delete';
+    id?: string;
+    status: number;
+    error?: {
+        type: string;
+        reason: string;
+    };
+}
+/** Result of a `bulk()` call. */
+export interface BulkResult {
+    errors: boolean;
+    items: BulkItemResult[];
+    took: number;
+}
+/** Parameters accepted by `search()`. */
+export interface SearchParams {
+    /** Query DSL query (match/term/bool/range/etc.). Omit to match all documents. */
+    query?: estypes.QueryDslQueryContainer;
+    /** Zero-based offset into the result set, for pagination. */
+    from?: number;
+    /** Max number of hits to return. */
+    size?: number;
+    /** Sort order - a field name, `{ field: 'asc' | 'desc' }`, or the driver's raw `Sort` shape. */
+    sort?: estypes.Sort;
+    /** Named aggregations to compute alongside the search. */
+    aggs?: Record<string, estypes.AggregationsAggregationContainer>;
+    /** Restrict/exclude which `_source` fields are returned. */
+    source?: boolean | string | string[];
+    /** Track the exact total hit count (rather than capping at 10,000). */
+    trackTotalHits?: boolean | number;
+}
+/** A single search hit. */
+export interface SearchHit<T = Record<string, unknown>> {
+    id: string;
+    index: string;
+    score: number | null;
+    source: T | undefined;
+    sort?: (string | number | null)[];
+}
+/** Result of a `search()` call. */
+export interface SearchResult<T = Record<string, unknown>> {
+    hits: SearchHit<T>[];
+    /** Total number of matching documents. `relation` is `'gte'` when the exact count wasn't tracked. */
+    total: {
+        value: number;
+        relation: 'eq' | 'gte';
+    };
+    maxScore: number | null;
+    tookMs: number;
+    /** Raw aggregation results, keyed by aggregation name, when `aggs` was requested. */
+    aggregations?: Record<string, unknown>;
+}
+declare function isNotFoundError(err: unknown): boolean;
+declare function isConflictError(err: unknown): boolean;
+/**
+ * `ElasticsearchStore` wraps the official `@elastic/elasticsearch` v9
+ * client and exposes index management, document CRUD (single + bulk),
+ * Query-DSL search, and alias management as a typed, promise-based API.
+ */
+export declare class ElasticsearchStore implements NoSqlStore {
+    readonly name = "elasticsearch";
+    readonly library = "@elastic/elasticsearch";
+    private readonly options;
+    private client;
+    private connected;
+    constructor(options: ElasticsearchStoreOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying `@elastic/elasticsearch` client for anything not wrapped here. */
+    getClient(): Client;
+    private requireClient;
+    private exec;
+    /** Create an index, optionally with mappings/settings/aliases. */
+    createIndex(index: string, options?: CreateIndexOptions): Promise<void>;
+    /** Delete an index. Resolves without error if the index doesn't exist. */
+    deleteIndex(index: string): Promise<void>;
+    /** Whether an index exists. */
+    indexExists(index: string): Promise<boolean>;
+    /** Get the field mappings for an index. */
+    getMapping(index: string): Promise<estypes.MappingTypeMapping | undefined>;
+    /** Add/update field mappings on an existing index. Mapping updates are additive - existing field mappings cannot be changed, only new fields added. */
+    putMapping(index: string, mappings: estypes.MappingTypeMapping): Promise<void>;
+    /** Get an index's settings. */
+    getSettings(index: string): Promise<estypes.IndicesIndexSettings | undefined>;
+    /** Update dynamic index settings (e.g. `number_of_replicas`, `refresh_interval`). Static settings like `number_of_shards` require closing the index first (not wrapped here - use `getClient()`). */
+    putSettings(index: string, settings: estypes.IndicesIndexSettings): Promise<void>;
+    /** Refresh an index so recently-written documents become visible to search immediately, rather than waiting for the automatic refresh interval. */
+    refreshIndex(index: string): Promise<void>;
+    /**
+     * Index (create or overwrite) a document. Omit `id` to let Elasticsearch
+     * auto-generate one. Returns the assigned `_id`.
+     */
+    indexDocument(index: string, document: Record<string, unknown>, options?: IndexDocumentOptions & {
+        id?: string;
+    }): Promise<string>;
+    /** Get a document by ID. Returns `null` if it doesn't exist. */
+    getDocument<T = Record<string, unknown>>(index: string, id: string): Promise<T | null>;
+    /** Whether a document exists. */
+    documentExists(index: string, id: string): Promise<boolean>;
+    /**
+     * Partially update a document by merging `partial` into the stored
+     * `_source`. Pass `options.upsert` to insert that document if `id`
+     * doesn't already exist yet. Throws `EmptyResultError` if the document
+     * doesn't exist and no `upsert` was provided.
+     */
+    updateDocument(index: string, id: string, partial: Record<string, unknown>, options?: UpdateDocumentOptions): Promise<void>;
+    /**
+     * Delete a document by ID. Returns `true` if a document was deleted,
+     * `false` if it didn't exist (rather than throwing, since "already
+     * gone" is a common, non-exceptional outcome for a delete).
+     */
+    deleteDocument(index: string, id: string, options?: DeleteDocumentOptions): Promise<boolean>;
+    /**
+     * Run a batch of index/create/update/delete operations in a single
+     * request. Unlike a SQL transaction, this is not atomic - each item
+     * succeeds or fails independently; check `result.errors` and each
+     * item's `error` field rather than assuming all-or-nothing.
+     */
+    bulk(actions: BulkAction[]): Promise<BulkResult>;
+    /** Convenience wrapper around `bulk()` for indexing many documents into one index at once. */
+    bulkIndex(index: string, documents: {
+        id?: string;
+        document: Record<string, unknown>;
+    }[]): Promise<BulkResult>;
+    /** Convenience wrapper around `bulk()` for deleting many documents from one index at once. */
+    bulkDelete(index: string, ids: string[]): Promise<BulkResult>;
+    /**
+     * Run a Query DSL search (`match`/`term`/`bool`/`range`/etc.) against
+     * one or more indices (comma-separated, or a wildcard pattern). Supports
+     * `from`/`size` pagination, `sort`, and named `aggs`.
+     */
+    search<T = Record<string, unknown>>(index: string, params?: SearchParams): Promise<SearchResult<T>>;
+    /** Count documents matching a query (or all documents, if `query` is omitted) without fetching them. */
+    count(index: string, query?: estypes.QueryDslQueryContainer): Promise<number>;
+    /** Point an alias at an index, creating the alias if it doesn't exist. */
+    putAlias(index: string, alias: string): Promise<void>;
+    /** Remove an alias from an index. */
+    deleteAlias(index: string, alias: string): Promise<void>;
+    /** List the indices an alias currently points at. */
+    getAlias(alias: string): Promise<string[]>;
+    /**
+     * Atomically repoint an alias from one index to another - the standard
+     * zero-downtime reindex pattern (build the new index, then swap the
+     * alias in one request so readers never see a moment with no index
+     * behind the alias).
+     */
+    swapAlias(alias: string, fromIndex: string, toIndex: string): Promise<void>;
+}
+export { isNotFoundError as isElasticsearchNotFoundError, isConflictError as isElasticsearchConflictError };
+export default ElasticsearchStore;