@getzep/zep-cloud 1.0.12 → 2.0.0-rc.2

package/langchain/utils.js

@@ -1,44 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.condenseZepMemoryIntoHumanMessage = exports.getZepMessageRoleType = void 0;
-const messages_1 = require("@langchain/core/messages");
-const getZepMessageRoleType = (role) => {
-    switch (role) {
-        case "human":
-            return "user";
-        case "ai":
-            return "assistant";
-        case "system":
-            return "system";
-        case "function":
-            return "function";
-        case "tool":
-            return "tool";
-        default:
-            return "norole";
-    }
-};
-exports.getZepMessageRoleType = getZepMessageRoleType;
-const condenseZepMemoryIntoHumanMessage = (memory) => {
-    var _a;
-    let systemPrompt = "";
-    if (memory.relevantFacts) {
-        const relevantFactStrings = memory.relevantFacts.map(({ fact }) => fact).filter(x => !!x);
-        systemPrompt += relevantFactStrings.join("\n");
-    }
-    // Extract summary, if present, and messages
-    if (memory.summary && ((_a = memory.summary) === null || _a === void 0 ? void 0 : _a.content)) {
-        systemPrompt += memory.summary.content;
-    }
-    let concatMessages = "";
-    if (memory.messages) {
-        concatMessages = memory.messages
-            .map((msg) => {
-            var _a;
-            return `${(_a = msg.role) !== null && _a !== void 0 ? _a : msg.roleType}: ${msg.content}`;
-        })
-            .join("\n");
-    }
-    return new messages_1.HumanMessage(systemPrompt + "\n" + concatMessages);
-};
-exports.condenseZepMemoryIntoHumanMessage = condenseZepMemoryIntoHumanMessage;

package/langchain/vector_store.d.ts

@@ -1,142 +0,0 @@
-import type { EmbeddingsInterface } from "@langchain/core/embeddings";
-import { MaxMarginalRelevanceSearchOptions, VectorStore } from "@langchain/core/vectorstores";
-import { Document } from "@langchain/core/documents";
-import { Callbacks } from "@langchain/core/callbacks/manager";
-import { ZepClient } from "../";
-/**
- * Interface for the configuration options for a ZepVectorStore instance.
- */
-export interface IZepConfig {
-    apiUrl?: string;
-    apiKey?: string;
-    client?: ZepClient;
-    collectionName: string;
-    description?: string;
-    metadata?: Record<string, never>;
-}
-/**
- * Interface for the parameters required to delete documents from a
- * ZepVectorStore instance.
- */
-export interface IZepDeleteParams {
-    uuids: string[];
-}
-/**
- * ZepVectorStore is a VectorStore implementation
- * that uses the Zep long-term memory store as a backend.
- *
- * If the collection does not exist, it will be created automatically.
- *
- * Requires `zep-js` to be installed:
- * ```bash
- * npm install @getzep/zep-js
- * ```
- *
- * @property {ZepClient} client - The ZepClient instance used to interact with Zep's API.
- * @property {Promise<void>} initPromise - A promise that resolves
- * when the collection is initialized.
- * @property {DocumentCollection} collection - The Zep document collection.
- */
-export declare class ZepVectorStore extends VectorStore {
-    client: ZepClient;
-    collectionName: string;
-    private readonly initPromise;
-    constructor(embeddings: EmbeddingsInterface, args: IZepConfig);
-    /**
-     * Initializes the document collection. If the collection does not exist, it creates a new one.
-     *
-     * @param {IZepConfig} args - The configuration object for the Zep API.
-     */
-    private initCollection;
-    /**
-     * Creates a new document collection.
-     *
-     * @param {IZepConfig} args - The configuration object for the Zep API.
-     */
-    private createCollection;
-    /**
-     * Adds vectors and corresponding documents to the collection.
-     *
-     * @param {number[][]} vectors - The vectors to add.
-     * @param {Document[]} documents - The corresponding documents to add.
-     * @returns {Promise<string[]>} - A promise that resolves with the UUIDs of the added documents.
-     */
-    addVectors(vectors: number[][], documents: Document[]): Promise<string[]>;
-    /**
-     * Adds documents to the collection. The documents are first embedded into vectors
-     * using the provided embedding model.
-     *
-     * @param {Document[]} documents - The documents to add.
-     * @returns {Promise<string[]>} - A promise that resolves with the UUIDs of the added documents.
-     */
-    addDocuments(documents: Document[]): Promise<string[]>;
-    _vectorstoreType(): string;
-    /**
-     * Deletes documents from the collection.
-     *
-     * @param {IZepDeleteParams} params - The list of Zep document UUIDs to delete.
-     * @returns {Promise<void>}
-     */
-    delete(params: IZepDeleteParams): Promise<void>;
-    /**
-     * Performs a similarity search in the collection and returns the results with their scores.
-     *
-     * @param {number[]} query - The query vector.
-     * @param {number} k - The number of results to return.
-     * @param {Record<string, unknown>} filter - The filter to apply to the search. Zep only supports Record<string, unknown> as filter.
-     * @returns {Promise<[Document, number][]>} - A promise that resolves with the search results and their scores.
-     */
-    similaritySearchVectorWithScore(query: number[], k: number, filter?: Record<string, unknown> | undefined): Promise<[Document, number][]>;
-    _similaritySearchWithScore(query: string, k: number, filter?: Record<string, unknown> | undefined): Promise<[Document, number][]>;
-    similaritySearchWithScore(query: string, k?: number, filter?: Record<string, unknown> | undefined, _callbacks?: undefined): Promise<[Document, number][]>;
-    /**
-     * Performs a similarity search on the Zep collection.
-     *
-     * @param {string} query - The query string to search for.
-     * @param {number} [k=4] - The number of results to return. Defaults to 4.
-     * @param {this["FilterType"] | undefined} [filter=undefined] - An optional set of JSONPath filters to apply to the search.
-     * @param {Callbacks | undefined} [_callbacks=undefined] - Optional callbacks. Currently not implemented.
-     * @returns {Promise<Document[]>} - A promise that resolves to an array of Documents that are similar to the query.
-     *
-     * @async
-     */
-    similaritySearch(query: string, k?: number, filter?: this["FilterType"] | undefined, _callbacks?: Callbacks | undefined): Promise<Document[]>;
-    /**
-     * Return documents selected using the maximal marginal relevance.
-     * Maximal marginal relevance optimizes for similarity to the query AND diversity
-     * among selected documents.
-     *
-     * @param {string} query - Text to look up documents similar to.
-     * @param options
-     * @param {number} options.k - Number of documents to return.
-     * @param {number} options.fetchK=20- Number of documents to fetch before passing to the MMR algorithm.
-     * @param {number} options.lambda=0.5 - Number between 0 and 1 that determines the degree of diversity among the results,
-     *                 where 0 corresponds to maximum diversity and 1 to minimum diversity.
-     * @param {Record<string, any>} options.filter - Optional Zep JSONPath query to pre-filter on document metadata field
-     *
-     * @returns {Promise<Document[]>} - List of documents selected by maximal marginal relevance.
-     */
-    maxMarginalRelevanceSearch(query: string, options: MaxMarginalRelevanceSearchOptions<this["FilterType"]>): Promise<Document[]>;
-    static init(zepConfig: IZepConfig): Promise<ZepVectorStore>;
-    /**
-     * Creates a new ZepVectorStore instance from an array of texts. Each text is converted into a Document and added to the collection.
-     *
-     * @param {string[]} texts - The texts to convert into Documents.
-     * @param {object[] | object} metadatas - The metadata to associate with each Document.
-     * If an array is provided, each element is associated with the corresponding Document.
-     * If an object is provided, it is associated with all Documents.
-     * @param {Embeddings} embeddings - The embeddings to use for vectorizing the texts.
-     * @param {IZepConfig} zepConfig - The configuration object for the Zep API.
-     * @returns {Promise<ZepVectorStore>} - A promise that resolves with the new ZepVectorStore instance.
-     */
-    static fromTexts(texts: string[], metadatas: object[] | object, embeddings: EmbeddingsInterface, zepConfig: IZepConfig): Promise<ZepVectorStore>;
-    /**
-     * Creates a new ZepVectorStore instance from an array of Documents. Each Document is added to a Zep collection.
-     *
-     * @param {Document[]} docs - The Documents to add.
-     * @param {Embeddings} embeddings - The embeddings to use for vectorizing the Document contents.
-     * @param {IZepConfig} zepConfig - The configuration object for the Zep API.
-     * @returns {Promise<ZepVectorStore>} - A promise that resolves with the new ZepVectorStore instance.
-     */
-    static fromDocuments(docs: Document[], embeddings: EmbeddingsInterface, zepConfig: IZepConfig): Promise<ZepVectorStore>;
-}

package/langchain/vector_store.js

@@ -1,327 +0,0 @@
-"use strict";
-/* eslint import/no-extraneous-dependencies: 0 */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __asyncValues = (this && this.__asyncValues) || function (o) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var m = o[Symbol.asyncIterator], i;
-    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
-    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ZepVectorStore = void 0;
-const vectorstores_1 = require("@langchain/core/vectorstores");
-const documents_1 = require("@langchain/core/documents");
-const math_1 = require("@langchain/core/utils/math");
-const testing_1 = require("@langchain/core/utils/testing");
-const api_1 = require("../api");
-const __1 = require("../");
-function zepDocsToDocumentsAndScore(results) {
-    return results.map((d) => {
-        var _a;
-        return [
-            new documents_1.Document({
-                pageContent: (_a = d.content) !== null && _a !== void 0 ? _a : "",
-                metadata: d.metadata,
-            }),
-            d.score ? d.score : 0,
-        ];
-    });
-}
-function assignMetadata(value) {
-    if (typeof value === "object" && value !== null) {
-        return value;
-    }
-    if (value !== undefined) {
-        console.warn("Metadata filters must be an object, Record, or undefined.");
-    }
-    return undefined;
-}
-/**
- * ZepVectorStore is a VectorStore implementation
- * that uses the Zep long-term memory store as a backend.
- *
- * If the collection does not exist, it will be created automatically.
- *
- * Requires `zep-js` to be installed:
- * ```bash
- * npm install @getzep/zep-js
- * ```
- *
- * @property {ZepClient} client - The ZepClient instance used to interact with Zep's API.
- * @property {Promise<void>} initPromise - A promise that resolves
- * when the collection is initialized.
- * @property {DocumentCollection} collection - The Zep document collection.
- */
-class ZepVectorStore extends vectorstores_1.VectorStore {
-    constructor(embeddings, args) {
-        super(embeddings, args);
-        this.initPromise = this.initCollection(args).catch((err) => {
-            console.error("Error initializing collection:", err);
-            throw err;
-        });
-    }
-    /**
-     * Initializes the document collection. If the collection does not exist, it creates a new one.
-     *
-     * @param {IZepConfig} args - The configuration object for the Zep API.
-     */
-    initCollection(args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (args.client) {
-                this.client = args.client;
-            }
-            else {
-                this.client = new __1.ZepClient({
-                    apiKey: args.apiKey,
-                    environment: args.apiUrl,
-                });
-            }
-            try {
-                this.collectionName = args.collectionName;
-                yield this.client.document.getCollection(this.collectionName);
-            }
-            catch (err) {
-                if (err instanceof Error) {
-                    if (err instanceof api_1.NotFoundError || err.name === "NotFoundError") {
-                        yield this.createCollection(args);
-                    }
-                    else {
-                        throw err;
-                    }
-                }
-            }
-        });
-    }
-    /**
-     * Creates a new document collection.
-     *
-     * @param {IZepConfig} args - The configuration object for the Zep API.
-     */
-    createCollection(args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.client.document.addCollection(args.collectionName, {
-                description: args.description,
-                metadata: args.metadata,
-            });
-            // eslint-disable-next-line no-console
-            console.info("Created new collection:", args.collectionName);
-        });
-    }
-    /**
-     * Adds vectors and corresponding documents to the collection.
-     *
-     * @param {number[][]} vectors - The vectors to add.
-     * @param {Document[]} documents - The corresponding documents to add.
-     * @returns {Promise<string[]>} - A promise that resolves with the UUIDs of the added documents.
-     */
-    addVectors(vectors, documents) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const docs = [];
-            for (let i = 0; i < documents.length; i += 1) {
-                const doc = {
-                    content: documents[i].pageContent,
-                    metadata: documents[i].metadata,
-                };
-                docs.push(doc);
-            }
-            // Wait for collection to be initialized
-            yield this.initPromise;
-            return this.client.document.addDocuments(this.collectionName, docs);
-        });
-    }
-    /**
-     * Adds documents to the collection. The documents are first embedded into vectors
-     * using the provided embedding model.
-     *
-     * @param {Document[]} documents - The documents to add.
-     * @returns {Promise<string[]>} - A promise that resolves with the UUIDs of the added documents.
-     */
-    addDocuments(documents) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const vectors = [];
-            return this.addVectors(vectors, documents);
-        });
-    }
-    // eslint-disable-next-line class-methods-use-this,no-underscore-dangle
-    _vectorstoreType() {
-        return "zep";
-    }
-    /**
-     * Deletes documents from the collection.
-     *
-     * @param {IZepDeleteParams} params - The list of Zep document UUIDs to delete.
-     * @returns {Promise<void>}
-     */
-    delete(params) {
-        var e_1, _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            // Wait for collection to be initialized
-            yield this.initPromise;
-            try {
-                // eslint-disable-next-line no-restricted-syntax
-                for (var _b = __asyncValues(params.uuids), _c; _c = yield _b.next(), !_c.done;) {
-                    const uuid = _c.value;
-                    yield this.client.document.deleteDocument(this.collectionName, uuid);
-                }
-            }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
-                try {
-                    if (_c && !_c.done && (_a = _b.return)) yield _a.call(_b);
-                }
-                finally { if (e_1) throw e_1.error; }
-            }
-        });
-    }
-    /**
-     * Performs a similarity search in the collection and returns the results with their scores.
-     *
-     * @param {number[]} query - The query vector.
-     * @param {number} k - The number of results to return.
-     * @param {Record<string, unknown>} filter - The filter to apply to the search. Zep only supports Record<string, unknown> as filter.
-     * @returns {Promise<[Document, number][]>} - A promise that resolves with the search results and their scores.
-     */
-    similaritySearchVectorWithScore(query, k, filter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Deprecated
-            console.warn("Zep does not support vector search. Using text search instead.");
-            return [];
-        });
-    }
-    // eslint-disable-next-line no-underscore-dangle
-    _similaritySearchWithScore(query, k, filter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.initPromise;
-            const { results } = yield this.client.document.search(this.collectionName, {
-                text: query,
-                metadata: assignMetadata(filter),
-                limit: k,
-            });
-            return zepDocsToDocumentsAndScore(results);
-        });
-    }
-    similaritySearchWithScore(query, k = 4, filter = undefined, 
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    _callbacks = undefined // implement passing to embedQuery later
-    ) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this._similaritySearchWithScore(query, k, filter);
-        });
-    }
-    /**
-     * Performs a similarity search on the Zep collection.
-     *
-     * @param {string} query - The query string to search for.
-     * @param {number} [k=4] - The number of results to return. Defaults to 4.
-     * @param {this["FilterType"] | undefined} [filter=undefined] - An optional set of JSONPath filters to apply to the search.
-     * @param {Callbacks | undefined} [_callbacks=undefined] - Optional callbacks. Currently not implemented.
-     * @returns {Promise<Document[]>} - A promise that resolves to an array of Documents that are similar to the query.
-     *
-     * @async
-     */
-    similaritySearch(query, k = 4, filter = undefined, 
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    _callbacks = undefined // implement passing to embedQuery later
-    ) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.initPromise;
-            const { results: zepResults } = yield this.client.document.search(this.collectionName, {
-                text: query,
-                metadata: assignMetadata(filter),
-                limit: k,
-            });
-            const results = zepDocsToDocumentsAndScore(zepResults);
-            return results.map((result) => result[0]);
-        });
-    }
-    /**
-     * Return documents selected using the maximal marginal relevance.
-     * Maximal marginal relevance optimizes for similarity to the query AND diversity
-     * among selected documents.
-     *
-     * @param {string} query - Text to look up documents similar to.
-     * @param options
-     * @param {number} options.k - Number of documents to return.
-     * @param {number} options.fetchK=20- Number of documents to fetch before passing to the MMR algorithm.
-     * @param {number} options.lambda=0.5 - Number between 0 and 1 that determines the degree of diversity among the results,
-     *                 where 0 corresponds to maximum diversity and 1 to minimum diversity.
-     * @param {Record<string, any>} options.filter - Optional Zep JSONPath query to pre-filter on document metadata field
-     *
-     * @returns {Promise<Document[]>} - List of documents selected by maximal marginal relevance.
-     */
-    maxMarginalRelevanceSearch(query, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { k, fetchK = 20, lambda = 0.5, filter } = options;
-            const r = yield this.client.document.search(this.collectionName, {
-                text: query,
-                metadata: assignMetadata(filter),
-                limit: fetchK,
-            });
-            const queryEmbedding = Array.from(r.queryVector);
-            const results = zepDocsToDocumentsAndScore(r.results);
-            const embeddingList = r.results.map((doc) => Array.from(doc.embedding ? doc.embedding : []));
-            const mmrIndexes = (0, math_1.maximalMarginalRelevance)(queryEmbedding, embeddingList, lambda, k);
-            return mmrIndexes.filter((idx) => idx !== -1).map((idx) => results[idx][0]);
-        });
-    }
-    static init(zepConfig) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const instance = new this(new testing_1.FakeEmbeddings(), zepConfig);
-            // Wait for collection to be initialized
-            yield instance.initPromise;
-            return instance;
-        });
-    }
-    /**
-     * Creates a new ZepVectorStore instance from an array of texts. Each text is converted into a Document and added to the collection.
-     *
-     * @param {string[]} texts - The texts to convert into Documents.
-     * @param {object[] | object} metadatas - The metadata to associate with each Document.
-     * If an array is provided, each element is associated with the corresponding Document.
-     * If an object is provided, it is associated with all Documents.
-     * @param {Embeddings} embeddings - The embeddings to use for vectorizing the texts.
-     * @param {IZepConfig} zepConfig - The configuration object for the Zep API.
-     * @returns {Promise<ZepVectorStore>} - A promise that resolves with the new ZepVectorStore instance.
-     */
-    static fromTexts(texts, metadatas, embeddings, zepConfig) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const docs = [];
-            for (let i = 0; i < texts.length; i += 1) {
-                const metadata = Array.isArray(metadatas) ? metadatas[i] : metadatas;
-                const newDoc = new documents_1.Document({
-                    pageContent: texts[i],
-                    metadata,
-                });
-                docs.push(newDoc);
-            }
-            return ZepVectorStore.fromDocuments(docs, embeddings, zepConfig);
-        });
-    }
-    /**
-     * Creates a new ZepVectorStore instance from an array of Documents. Each Document is added to a Zep collection.
-     *
-     * @param {Document[]} docs - The Documents to add.
-     * @param {Embeddings} embeddings - The embeddings to use for vectorizing the Document contents.
-     * @param {IZepConfig} zepConfig - The configuration object for the Zep API.
-     * @returns {Promise<ZepVectorStore>} - A promise that resolves with the new ZepVectorStore instance.
-     */
-    static fromDocuments(docs, embeddings, zepConfig) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const instance = new this(embeddings, zepConfig);
-            // Wait for collection to be initialized
-            yield instance.initPromise;
-            yield instance.addDocuments(docs);
-            return instance;
-        });
-    }
-}
-exports.ZepVectorStore = ZepVectorStore;

package/langchain/zep_memory.d.ts

@@ -1,78 +0,0 @@
-import { InputValues, MemoryVariables, OutputValues } from "@langchain/core/memory";
-import { BaseChatMemory, BaseChatMemoryInput } from "langchain/memory";
-import { ZepClient } from "../";
-export interface ZepMemoryInput extends BaseChatMemoryInput {
-    humanPrefix?: string;
-    aiPrefix?: string;
-    memoryKey?: string;
-    baseURL?: string;
-    sessionId: string;
-    apiKey: string;
-}
-/**
- * Class used to manage the memory of a chat session, including loading
- * and saving the chat history, and clearing the memory when needed. It
- * uses the ZepClient to interact with the Zep service for managing the
- * chat session's memory.
- * @example
- * ```typescript
- * const sessionId = randomUUID();
- *
- * // Initialize ZepMemory with session ID, base URL, and API key
- * const memory = new ZepMemory({
- *   sessionId,
- *   apiKey: "change_this_key",
- * });
- *
- * // Create a ChatOpenAI model instance with specific parameters
- * const model = new ChatOpenAI({
- *   modelName: "gpt-3.5-turbo",
- *   temperature: 0,
- * });
- *
- * // Create a ConversationChain with the model and memory
- * const chain = new ConversationChain({ llm: model, memory });
- *
- * // Example of calling the chain with an input
- * const res1 = await chain.call({ input: "Hi! I'm Jim." });
- * console.log({ res1 });
- *
- * // Follow-up call to the chain to demonstrate memory usage
- * const res2 = await chain.call({ input: "What did I just say my name was?" });
- * console.log({ res2 });
- *
- * // Output the session ID and the current state of memory
- * console.log("Session ID: ", sessionId);
- * console.log("Memory: ", await memory.loadMemoryVariables({}));
- *
- * ```
- */
-export declare class ZepMemory extends BaseChatMemory implements ZepMemoryInput {
-    humanPrefix: string;
-    aiPrefix: string;
-    memoryKey: string;
-    apiKey: string;
-    sessionId: string;
-    zepClient: ZepClient;
-    constructor(fields: ZepMemoryInput);
-    get memoryKeys(): string[];
-    /**
-     * Method that retrieves the chat history from the Zep service and formats
-     * it into a list of messages.
-     * @param values Input values for the method.
-     * @returns Promise that resolves with the chat history formatted into a list of messages.
-     */
-    loadMemoryVariables(values: InputValues): Promise<MemoryVariables>;
-    /**
-     * Method that saves the input and output messages to the Zep service.
-     * @param inputValues Input messages to be saved.
-     * @param outputValues Output messages to be saved.
-     * @returns Promise that resolves when the messages have been saved.
-     */
-    saveContext(inputValues: InputValues, outputValues: OutputValues): Promise<void>;
-    /**
-     * Method that deletes the chat history from the Zep service.
-     * @returns Promise that resolves when the chat history has been deleted.
-     */
-    clear(): Promise<void>;
-}