@tstdl/base 0.92.167 → 0.92.168

package/search-index/elastic/query-converter.js

@@ -1,183 +0,0 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-import { hasOwnProperty, objectEntries, objectValues } from '../../utils/object/object.js';
-import { assertDefinedPass, isPrimitive, isRegExp, isString } from '../../utils/type-guards.js';
-import { BoolQueryBuilder } from './query-builder/index.js';
-// eslint-disable-next-line max-lines-per-function, max-statements, complexity
-export function convertQuery(query) {
-    const defaultBoolQueryBuilder = new BoolQueryBuilder();
-    const queryEntries = objectEntries(query);
-    // eslint-disable-next-line no-unreachable-loop
-    for (const [rawProperty, value] of queryEntries) {
-        const property = getPropertyName(rawProperty);
-        const isPrimitiveValue = isPrimitive(value);
-        const range = {};
-        let canHandleProperty = false;
-        if (rawProperty == '$and') {
-            if (queryEntries.length > 1) {
-                throw new Error('only one logical operator per level allowed');
-            }
-            return convertLogicalAndQuery(value);
-        }
-        if (rawProperty == '$or') {
-            if (queryEntries.length > 1) {
-                throw new Error('only one logical operator per level allowed');
-            }
-            return convertLogicalOrQuery(value);
-        }
-        if (rawProperty == '$nor') {
-            if (queryEntries.length > 1) {
-                throw new Error('only one logical operator per level allowed');
-            }
-            return convertLogicalNorQuery(value);
-        }
-        if (rawProperty == '$textSpan') {
-            const { fields, text, mode, operator } = value;
-            const type = convertTextSpanQueryMode(mode);
-            const matchQuery = { multi_match: { fields, query: text, type, operator } };
-            defaultBoolQueryBuilder.must(matchQuery);
-            canHandleProperty = true;
-        }
-        if (isPrimitiveValue || hasOwnProperty(value, '$eq')) {
-            const termQuery = {
-                term: { [property]: isPrimitiveValue ? value : value.$eq }
-            };
-            defaultBoolQueryBuilder.must(termQuery);
-            canHandleProperty = true;
-        }
-        if (hasOwnProperty(value, '$neq')) {
-            const termQuery = {
-                term: { [property]: value.$neq }
-            };
-            defaultBoolQueryBuilder.mustNot(termQuery);
-            canHandleProperty = true;
-        }
-        if (hasOwnProperty(value, '$exists')) {
-            const existsQuery = { exists: { field: property } };
-            if (value.$exists) {
-                defaultBoolQueryBuilder.must(existsQuery);
-            }
-            else {
-                defaultBoolQueryBuilder.mustNot(existsQuery);
-            }
-            canHandleProperty = true;
-        }
-        if (hasOwnProperty(value, '$in')) {
-            const termQuery = {
-                terms: { [property]: value.$in }
-            };
-            defaultBoolQueryBuilder.must(termQuery);
-            canHandleProperty = true;
-        }
-        if (hasOwnProperty(value, '$nin')) {
-            const termQuery = {
-                terms: { [property]: value.$nin }
-            };
-            defaultBoolQueryBuilder.mustNot(termQuery);
-            canHandleProperty = true;
-        }
-        if (hasOwnProperty(value, '$lt')) {
-            range.lt = value.$lt;
-            canHandleProperty = true;
-        }
-        if (hasOwnProperty(value, '$lte')) {
-            range.lte = value.$lte;
-            canHandleProperty = true;
-        }
-        if (hasOwnProperty(value, '$gt')) {
-            range.gt = value.$gt;
-            canHandleProperty = true;
-        }
-        if (hasOwnProperty(value, '$gte')) {
-            range.gte = value.$gte;
-            canHandleProperty = true;
-        }
-        if (objectValues(range).length > 0) {
-            const rangeQuery = { range: { [property]: range } };
-            defaultBoolQueryBuilder.must(rangeQuery);
-        }
-        if (hasOwnProperty(value, '$regex')) {
-            const regex = value.$regex;
-            const regexp = isString(regex)
-                ? regex
-                : isRegExp(regex)
-                    ? { flags: regex.flags, value: regex.source }
-                    : { flags: regex.flags, value: regex.pattern };
-            const termQuery = {
-                regexp: { property: regexp }
-            };
-            defaultBoolQueryBuilder.must(termQuery);
-            canHandleProperty = true;
-        }
-        if (hasOwnProperty(value, '$text')) {
-            let matchQuery;
-            const textQueryValue = value.$text;
-            if (typeof textQueryValue == 'string') {
-                matchQuery = { match: { [property]: { query: textQueryValue } } };
-            }
-            else {
-                matchQuery = { match: { [property]: { query: textQueryValue.text, operator: textQueryValue.operator } } };
-            }
-            defaultBoolQueryBuilder.must(matchQuery);
-            canHandleProperty = true;
-        }
-        if (hasOwnProperty(value, '$geoShape')) {
-            const geoShapeQuery = {
-                geo_shape: {
-                    [property]: {
-                        shape: value.$geoShape.geometry,
-                        relation: value.$geoShape.relation
-                    }
-                }
-            };
-            defaultBoolQueryBuilder.must(geoShapeQuery);
-            canHandleProperty = true;
-        }
-        if (hasOwnProperty(value, '$geoDistance')) {
-            const distance = assertDefinedPass(value.$geoDistance.maxDistance, 'maxDistance required');
-            const geoShapeQuery = {
-                geo_distance: {
-                    distance: `${distance}m`,
-                    [property]: [
-                        value.$geoDistance.longitude,
-                        value.$geoDistance.latitude
-                    ]
-                }
-            };
-            defaultBoolQueryBuilder.must(geoShapeQuery);
-            canHandleProperty = true;
-        }
-        if (!canHandleProperty) {
-            throw new Error(`unsupported query type "${rawProperty}"`);
-        }
-    }
-    if (defaultBoolQueryBuilder.totalQueries == 0) {
-        return { match_all: {} };
-    }
-    return defaultBoolQueryBuilder.build();
-}
-function getPropertyName(property) {
-    return property == 'id' ? '_id' : property;
-}
-export function convertLogicalAndQuery(andQuery) {
-    return new BoolQueryBuilder().must(...andQuery.map(convertQuery)).build();
-}
-export function convertLogicalOrQuery(orQuery) {
-    return new BoolQueryBuilder().should(...orQuery.map(convertQuery)).build();
-}
-export function convertLogicalNorQuery(norQuery) {
-    return new BoolQueryBuilder().mustNot(...norQuery.map(convertQuery)).build();
-}
-export function convertTextSpanQueryMode(mode) {
-    switch (mode) {
-        case undefined:
-            return undefined;
-        case 'best':
-            return 'best_fields';
-        case 'most':
-            return 'most_fields';
-        case 'cross':
-            return 'cross_fields';
-        default:
-            throw new Error('unknown ComplexTextSpanQueryMode');
-    }
-}

package/search-index/elastic/search-index.d.ts

@@ -1,30 +0,0 @@
-import type { Client, estypes } from '@elastic/elasticsearch';
-import type { Entity, Query, QueryOptions } from '../../database/index.js';
-import type { AfterResolve } from '../../injector/interfaces.js';
-import { afterResolve } from '../../injector/interfaces.js';
-import type { Logger } from '../../logger/index.js';
-import type { SearchResult } from '../../search-index/index.js';
-import { SearchIndex } from '../../search-index/index.js';
-import type { ElasticSearchIndexConfig } from './config.js';
-import { KeywordRewriter } from './keyword-rewriter.js';
-import type { ElasticIndexMapping } from './model/index.js';
-export declare class ElasticSearchIndex<T extends Entity> extends SearchIndex<T> implements AfterResolve {
-    private readonly logger;
-    readonly client: Client;
-    readonly indexName: string;
-    readonly indexSettings: estypes.IndicesIndexSettings;
-    readonly indexMapping: ElasticIndexMapping<T>;
-    readonly keywordRewriter: KeywordRewriter;
-    constructor(client: Client, config: ElasticSearchIndexConfig<T>, indexSettings: estypes.IndicesIndexSettings, indexMapping: ElasticIndexMapping<T>, keywordRewrites: Iterable<string>, logger: Logger);
-    [afterResolve](): Promise<void>;
-    initialize(): Promise<void>;
-    refresh(): Promise<void>;
-    updateSettings(): Promise<void>;
-    index(entities: T[]): Promise<void>;
-    delete(id: string): Promise<void>;
-    deleteByQuery(query: Query<T>): Promise<void>;
-    search(searchQueryOrCursor: Query<T> | string, options?: QueryOptions<T>): Promise<SearchResult<T>>;
-    count(query?: Query<T>, options?: QueryOptions<T>): Promise<number>;
-    drop(): Promise<void>;
-    exists(): Promise<boolean>;
-}

package/search-index/elastic/search-index.js

@@ -1,144 +0,0 @@
-import { BadRequestError } from '../../errors/bad-request.error.js';
-import { MultiError } from '../../errors/multi.error.js';
-import { afterResolve } from '../../injector/interfaces.js';
-import { SearchIndex, SearchIndexError } from '../../search-index/index.js';
-import { decodeBase64, encodeBase64 } from '../../utils/base64.js';
-import { decodeText, encodeUtf8 } from '../../utils/encoding.js';
-import { filterObject } from '../../utils/object/object.js';
-import { isDefined, isNumber, isString } from '../../utils/type-guards.js';
-import { KeywordRewriter } from './keyword-rewriter.js';
-import { convertQuery } from './query-converter.js';
-import { convertSort } from './sort-converter.js';
-export class ElasticSearchIndex extends SearchIndex {
-    logger;
-    client;
-    indexName;
-    indexSettings;
-    indexMapping;
-    keywordRewriter;
-    constructor(client, config, indexSettings, indexMapping, keywordRewrites, logger) {
-        super();
-        this.client = client;
-        this.indexName = config.indexName;
-        this.indexSettings = indexSettings;
-        this.indexMapping = indexMapping;
-        this.logger = logger;
-        this.keywordRewriter = new KeywordRewriter(keywordRewrites);
-    }
-    async [afterResolve]() {
-        await this.initialize();
-    }
-    async initialize() {
-        const exists = await this.exists();
-        if (!exists) {
-            await this.client.indices.create({ index: this.indexName, mappings: this.indexMapping, settings: this.indexSettings });
-            this.logger.info(`created index ${this.indexName}`);
-        }
-    }
-    async refresh() {
-        await this.client.indices.refresh({ index: this.indexName });
-    }
-    async updateSettings() {
-        this.logger.info(`closing index ${this.indexName} for updates`);
-        await this.client.indices.close({ index: this.indexName });
-        this.logger.info(`closed index ${this.indexName} for updates`);
-        this.logger.info(`updating settings for index ${this.indexName}`);
-        await this.client.indices.putSettings({ index: this.indexName, settings: this.indexSettings });
-        this.logger.info(`updated settings for index ${this.indexName}`);
-        this.logger.info(`updating mapping for index ${this.indexName}`);
-        await this.client.indices.putMapping({ index: this.indexName, ...this.indexMapping });
-        this.logger.info(`updated mapping for index ${this.indexName}`);
-        this.logger.info(`reopening index ${this.indexName}`);
-        await this.client.indices.open({ index: this.indexName });
-        this.logger.info(`reopened index ${this.indexName}`);
-        this.logger.info(`refreshing index ${this.indexName}`);
-        await this.client.indices.refresh({ index: this.indexName });
-        this.logger.info(`refreshed index ${this.indexName}`);
-    }
-    async index(entities) {
-        const request = {
-            index: this.indexName,
-            refresh: false,
-            operations: entities.flatMap((entity) => {
-                const { id: _, ...entityWithoutId } = entity;
-                return [{ index: { _id: entity.id } }, entityWithoutId];
-            }),
-        };
-        const result = await this.client.bulk(request);
-        if (result.errors) {
-            const errorItems = result.items
-                .filter((item) => isDefined(item.index.error))
-                .map((item) => item.index);
-            const errors = errorItems.map((item) => convertError(item.error, item));
-            if (errors.length == 1) {
-                throw errors[0];
-            }
-            const multiError = new MultiError(errors);
-            throw new SearchIndexError('index error', 'multiple errors', { cause: multiError });
-        }
-    }
-    async delete(id) {
-        await this.client.delete({ index: this.indexName, id });
-    }
-    async deleteByQuery(query) {
-        const queryBody = convertQuery(query);
-        await this.client.deleteByQuery({ index: this.indexName, query: queryBody });
-    }
-    async search(searchQueryOrCursor, options) {
-        const cursorData = isString(searchQueryOrCursor) ? deserializeCursor(searchQueryOrCursor) : undefined;
-        const queryBody = isDefined(cursorData) ? cursorData.query : convertQuery(searchQueryOrCursor);
-        const search = { index: this.indexName, query: queryBody };
-        const windowLimit = this.indexSettings.max_result_window ?? 10000;
-        if ((options?.skip ?? 0) + (options?.limit ?? 0) > windowLimit) {
-            throw new BadRequestError(`Result window is too large, skip + limit must be less than or equal to ${windowLimit}. Use cursor for more results`);
-        }
-        if (isDefined(cursorData) && isDefined(options?.skip)) {
-            throw new Error('cursor and skip cannot be used at the same time');
-        }
-        const sort = cursorData?.sort ?? (options?.sort ?? []).map((sortItem) => convertSort(sortItem, this.keywordRewriter));
-        search.sort = sort;
-        search.from = options?.skip;
-        search.size = options?.limit ?? cursorData?.options?.limit;
-        search.search_after = cursorData?.searchAfter;
-        const response = await this.client.search(search);
-        const hits = response.hits.hits;
-        const resultItems = hits.map(({ _id, _score, _source }) => ({ score: _score ?? 1, entity: { id: _id, ..._source } }));
-        const total = isNumber(response.hits.total) ? response.hits.total : response.hits.total?.value;
-        const totalIsLowerBound = isNumber(response.hits.total) ? false : (response.hits.total?.relation == 'gte');
-        const cursor = (hits.length > 0) && (isDefined(hits[hits.length - 1].sort)) ? serializeCursor(queryBody, sort, { limit: search.size }, hits[hits.length - 1].sort) : undefined;
-        const result = { total, milliseconds: response.took, totalIsLowerBound, cursor, items: resultItems };
-        return result;
-    }
-    async count(query, options) {
-        if (isDefined(options?.skip) || isDefined(options?.limit)) {
-            throw new Error('Options skip and limit for count are not support in ElasticSearchIndex.');
-        }
-        const result = await this.client.count({
-            index: this.indexName,
-            query: convertQuery(query ?? {}),
-        });
-        return result.count;
-    }
-    async drop() {
-        const exists = await this.exists();
-        if (!exists) {
-            return;
-        }
-        await this.client.indices.delete({ index: this.indexName });
-    }
-    async exists() {
-        return await this.client.indices.exists({ index: this.indexName });
-    }
-}
-function serializeCursor(query, sort, options, searchAfter) {
-    const filteredOptions = isDefined(options) ? filterObject(options, isDefined) : undefined;
-    const data = { query, sort, options: filteredOptions, searchAfter };
-    return encodeBase64(encodeUtf8(JSON.stringify(data)));
-}
-function deserializeCursor(cursor) {
-    return JSON.parse(decodeText(decodeBase64(cursor)));
-}
-function convertError(error, raw) {
-    const cause = (isDefined(error.caused_by)) ? convertError(error.caused_by) : undefined;
-    return new SearchIndexError(error.type, error.reason ?? 'No error message provided.', { raw, cause });
-}

package/search-index/elastic/sort-converter.d.ts

@@ -1,4 +0,0 @@
-import type { Entity, Sort } from '../../database/index.js';
-import type { KeywordRewriter } from './keyword-rewriter.js';
-import type { SortCombinations } from './model/index.js';
-export declare function convertSort<T extends Entity>(sort: Sort<T>, keywordRewriter: KeywordRewriter): SortCombinations<T>;

package/search-index/elastic/sort-converter.js

@@ -1,14 +0,0 @@
-const renameMap = new Map([
-    ['id', '_id'],
-    ['$score', '_score']
-]);
-// eslint-disable-next-line max-lines-per-function, max-statements, complexity
-export function convertSort(sort, keywordRewriter) {
-    const name = renameMap.get(sort.field) ?? sort.field;
-    const field = keywordRewriter.rewriteIfRequired(name);
-    const order = sort.order ?? 'asc';
-    if (((field != '_score') && (order == 'asc')) || ((field == '_score') && (order == 'desc'))) {
-        return field;
-    }
-    return { [field]: order };
-}

package/search-index/elastic/types.d.ts

@@ -1,5 +0,0 @@
-import type { estypes } from '@elastic/elasticsearch';
-export type AnalysisAnalyzer = estypes.AnalysisAnalyzer;
-export type AnalysisTokenFilter = estypes.AnalysisTokenFilter;
-export type AnalysisTokenizer = estypes.AnalysisTokenizer;
-export type IndicesIndexSettings = estypes.IndicesIndexSettings;

package/search-index/elastic/types.js

@@ -1 +0,0 @@
-export {};

package/search-index/error.d.ts

@@ -1,10 +0,0 @@
-import { CustomError } from '../errors/custom.error.js';
-export declare class SearchIndexError extends CustomError {
-    static readonly errorName = "SearchIndexError";
-    readonly type: string;
-    readonly raw: unknown;
-    constructor(type: string, message: string, { raw, cause }?: {
-        raw?: unknown;
-        cause?: Error;
-    });
-}

package/search-index/error.js

@@ -1,14 +0,0 @@
-import { CustomError } from '../errors/custom.error.js';
-import { isDefined } from '../utils/type-guards.js';
-export class SearchIndexError extends CustomError {
-    static errorName = 'SearchIndexError';
-    type;
-    raw;
-    constructor(type, message, { raw, cause } = {}) {
-        super({ message, cause });
-        this.type = type;
-        if (isDefined(raw)) {
-            this.raw = raw;
-        }
-    }
-}

package/search-index/index.d.ts

@@ -1,3 +0,0 @@
-export * from './error.js';
-export * from './search-index.js';
-export * from './search-result.js';

package/search-index/index.js

@@ -1,3 +0,0 @@
-export * from './error.js';
-export * from './search-index.js';
-export * from './search-result.js';

package/search-index/memory/index.d.ts

@@ -1 +0,0 @@
-export * from './memory-search-index.js';

package/search-index/memory/index.js

@@ -1 +0,0 @@
-export * from './memory-search-index.js';

package/search-index/memory/memory-search-index.d.ts

@@ -1,19 +0,0 @@
-import type { Entity, Query, QueryOptions } from '../../database/index.js';
-import { SearchIndex } from '../search-index.js';
-import type { SearchResult } from '../search-result.js';
-export declare class MemorySearchIndex<T extends Entity> extends SearchIndex<T> {
-    private readonly indexedFields;
-    private readonly allSet;
-    private readonly idMap;
-    private readonly indexMap;
-    constructor(indexedFields: (keyof T)[]);
-    index(entities: T[]): Promise<void>;
-    delete(id: string): Promise<void>;
-    deleteByQuery(query: Query<T>): Promise<void>;
-    search(queryOrCursor: string | Query<T>, options?: QueryOptions<T>): Promise<SearchResult<T>>;
-    count(query?: Query<T>, options?: QueryOptions<T>): Promise<number>;
-    drop(): Promise<void>;
-    private _delete;
-    private indexEntity;
-    private deleteEntity;
-}

package/search-index/memory/memory-search-index.js

@@ -1,144 +0,0 @@
-import { compareByValueSelectionOrdered } from '../../utils/comparison.js';
-import { FactoryMap } from '../../utils/factory-map.js';
-import { objectEntries } from '../../utils/object/object.js';
-import { intersectSets, unionSets } from '../../utils/set.js';
-import { normalizeText } from '../../utils/string/index.js';
-import { Timer } from '../../utils/timer.js';
-import { isDefined, isNullOrUndefined, isString } from '../../utils/type-guards.js';
-import { SearchIndex } from '../search-index.js';
-export class MemorySearchIndex extends SearchIndex {
-    indexedFields;
-    allSet;
-    idMap;
-    indexMap;
-    constructor(indexedFields) {
-        super();
-        this.indexedFields = indexedFields;
-        this.allSet = new Set();
-        this.idMap = new Map();
-        this.indexMap = new FactoryMap(() => new FactoryMap(() => new Set()));
-    }
-    // eslint-disable-next-line @typescript-eslint/require-await
-    async index(entities) {
-        for (const entity of entities) {
-            this._delete(entity.id);
-            this.indexEntity(entity);
-        }
-    }
-    // eslint-disable-next-line @typescript-eslint/require-await
-    async delete(id) {
-        this._delete(id);
-    }
-    async deleteByQuery(query) {
-        const searchResult = await this.search(query);
-        for (const item of searchResult.items) {
-            this.deleteEntity(item.entity);
-        }
-    }
-    // eslint-disable-next-line @typescript-eslint/require-await, max-statements, max-lines-per-function
-    async search(queryOrCursor, options = {}) {
-        if (isString(queryOrCursor)) {
-            throw new Error('cursor not supported');
-        }
-        const timer = new Timer(true);
-        const entries = objectEntries(queryOrCursor);
-        let items;
-        if (entries.length == 0) {
-            items = [...this.allSet];
-        }
-        else {
-            const sets = [];
-            for (const [field, query] of entries) {
-                const textQuery = query.$text;
-                const queryIsString = isString(textQuery);
-                const text = queryIsString ? textQuery : textQuery.text;
-                const and = queryIsString ? true : textQuery.operator != 'or';
-                const innerSets = [];
-                if (isString(text)) {
-                    const tokens = normalizeText(text).split(' ').filter((token) => token.length > 0);
-                    if (tokens.length == 0) {
-                        innerSets.push(this.allSet);
-                    }
-                    for (const token of tokens) {
-                        innerSets.push(this.indexMap.get(field).get(token));
-                    }
-                }
-                const innerEntries = and ? intersectSets(...innerSets) : unionSets(...innerSets);
-                sets.push(new Set(innerEntries));
-            }
-            items = intersectSets(...sets);
-        }
-        if (isDefined(options.sort)) {
-            items.sort(compareByValueSelectionOrdered(...options.sort.map((sort) => [(item) => item[sort.field], sort.order == 'desc' ? -1 : 1])));
-        }
-        if (isDefined(options.skip) || isDefined(options.limit)) {
-            const start = options.skip ?? 0;
-            const end = isDefined(options.limit) ? (start + options.limit) : undefined;
-            items = items.slice(start, end);
-        }
-        const resultItems = items.map((item) => ({ entity: item, score: 1 }));
-        const result = {
-            total: resultItems.length,
-            totalIsLowerBound: false,
-            milliseconds: timer.milliseconds,
-            items: resultItems,
-        };
-        return result;
-    }
-    async count(query, options) {
-        const items = await this.searchAll(query ?? {}, options);
-        return items.length;
-    }
-    // eslint-disable-next-line @typescript-eslint/require-await
-    async drop() {
-        this.allSet.clear();
-        this.idMap.clear();
-        this.indexMap.clear();
-    }
-    _delete(id) {
-        const entity = this.idMap.get(id);
-        if (isDefined(entity)) {
-            this.deleteEntity(entity);
-        }
-    }
-    indexEntity(entity) {
-        this.allSet.add(entity);
-        this.idMap.set(entity.id, entity);
-        for (const field of this.indexedFields) {
-            const value = entity[field];
-            const tokens = getTokens(value);
-            for (const token of tokens) {
-                this.indexMap.get(field).get(token).add(entity);
-            }
-        }
-    }
-    deleteEntity(entity) {
-        for (const field of this.indexedFields) {
-            const value = entity[field];
-            const tokens = getTokens(value);
-            for (const token of tokens) {
-                this.indexMap.get(field).get(token).delete(entity);
-            }
-        }
-        this.allSet.delete(entity);
-        this.idMap.delete(entity.id);
-    }
-}
-function getTokens(value) {
-    if (isNullOrUndefined(value)) {
-        return [value];
-    }
-    if (!isString(value)) {
-        throw new Error('value is neither string nor null or undefined');
-    }
-    const normalizedParts = normalizeText(value).split(' ');
-    const tokens = new Set();
-    for (const part of normalizedParts) {
-        for (let i = 0; i < part.length; i++) {
-            for (let j = i; j < part.length; j++) {
-                tokens.add(part.slice(i, j + 1));
-            }
-        }
-    }
-    return [...tokens];
-}

package/search-index/search-index.d.ts

@@ -1,46 +0,0 @@
-import type { Entity } from '../database/entity.js';
-import type { Query, QueryOptions } from '../database/query.js';
-import type { SearchResult, SearchResultItem } from './search-result.js';
-export type SearchCursorOptions<T extends Entity> = QueryOptions<T> & {
-    batchSize?: number;
-};
-declare const type: unique symbol;
-export declare abstract class SearchIndex<T extends Entity> {
-    [type]: T;
-    /**
-     * search all entities using an automatic cursor
-     * @param query search query
-     * @param options search options
-     */
-    searchCursor(query: Query<T>, options?: SearchCursorOptions<T>): AsyncIterable<SearchResultItem<T>>;
-    /**
-     * search all entities instead of just a chunk
-     * @param query search query
-     * @param options search option
-     */
-    searchAll(query: Query<T>, options?: QueryOptions<T>): Promise<SearchResultItem<T>[]>;
-    /**
-     * index entities for search
-     * @param entities entities to index
-     */
-    abstract index(entities: T[]): Promise<void>;
-    /**
-     * delete entity from index
-     * @param id entity id to delete
-     */
-    abstract delete(id: string): Promise<void>;
-    /**
-     * delete matching entities from index
-     * @param query query to search for matching entities
-     */
-    abstract deleteByQuery(query: Query<T>): Promise<void>;
-    abstract search(query: Query<T>, options?: QueryOptions<T>): Promise<SearchResult<T>>;
-    abstract search(cursor: string, options?: QueryOptions<T>): Promise<SearchResult<T>>;
-    abstract search(queryOrCursor: Query<T> | string, options?: QueryOptions<T>): Promise<SearchResult<T>>;
-    abstract count(query?: Query<T>, options?: QueryOptions<T>): Promise<number>;
-    /**
-     * drop index. If you only want to delete all items from the index, use {@link deleteByQuery} with an empty query.
-     */
-    abstract drop(): Promise<void>;
-}
-export {};