@getzep/zep-cloud 0.0.1-rc.1

package/dist/langchain/vector_store.js

@@ -0,0 +1,328 @@
+"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,
+                    embedding: vectors.length > 0 ? vectors[i] : undefined,
+                };
+                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/dist/langchain/zep_memory.d.ts

@@ -0,0 +1,78 @@
+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>;
+}

package/dist/langchain/zep_memory.js

@@ -0,0 +1,174 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZepMemory = void 0;
+const memory_1 = require("@langchain/core/memory");
+const memory_2 = require("langchain/memory");
+const __1 = require("../");
+const api_1 = require("../api");
+const utils_1 = require("./utils");
+/**
+ * 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({}));
+ *
+ * ```
+ */
+class ZepMemory extends memory_2.BaseChatMemory {
+    constructor(fields) {
+        var _a, _b, _c, _d;
+        super({
+            returnMessages: (_a = fields === null || fields === void 0 ? void 0 : fields.returnMessages) !== null && _a !== void 0 ? _a : false,
+            inputKey: fields === null || fields === void 0 ? void 0 : fields.inputKey,
+            outputKey: fields === null || fields === void 0 ? void 0 : fields.outputKey,
+        });
+        this.humanPrefix = "Human";
+        this.aiPrefix = "AI";
+        this.memoryKey = "history";
+        this.humanPrefix = (_b = fields.humanPrefix) !== null && _b !== void 0 ? _b : this.humanPrefix;
+        this.aiPrefix = (_c = fields.aiPrefix) !== null && _c !== void 0 ? _c : this.aiPrefix;
+        this.memoryKey = (_d = fields.memoryKey) !== null && _d !== void 0 ? _d : this.memoryKey;
+        this.apiKey = fields.apiKey;
+        this.sessionId = fields.sessionId;
+        this.zepClient = new __1.ZepClient({
+            environment: fields.baseURL,
+            apiKey: this.apiKey,
+        });
+    }
+    get memoryKeys() {
+        return [this.memoryKey];
+    }
+    /**
+     * 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) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            // use either lastN provided by developer or undefined to use the
+            // server preset.
+            const memoryType = (_a = values.memoryType) !== null && _a !== void 0 ? _a : "perpetual";
+            let memory = null;
+            try {
+                memory = yield this.zepClient.memory.get(this.sessionId, {
+                    memoryType: memoryType,
+                });
+            }
+            catch (error) {
+                if (error instanceof api_1.NotFoundError) {
+                    return this.returnMessages ? { [this.memoryKey]: [] } : { [this.memoryKey]: "" };
+                }
+                throw error;
+            }
+            if (this.returnMessages) {
+                return {
+                    [this.memoryKey]: [(0, utils_1.condenseZepMemoryIntoHumanMessage)(memory)],
+                };
+            }
+            return {
+                [this.memoryKey]: (0, utils_1.condenseZepMemoryIntoHumanMessage)(memory).content,
+            };
+        });
+    }
+    /**
+     * 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, outputValues) {
+        const _super = Object.create(null, {
+            saveContext: { get: () => super.saveContext }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const input = (0, memory_1.getInputValue)(inputValues, this.inputKey);
+            const output = (0, memory_1.getOutputValue)(outputValues, this.outputKey);
+            // Add the new memory to the session using the ZepClient
+            if (this.sessionId) {
+                try {
+                    yield this.zepClient.memory.add(this.sessionId, {
+                        messages: [
+                            {
+                                role: this.humanPrefix,
+                                roleType: "user",
+                                content: `${input}`,
+                            },
+                            {
+                                role: this.aiPrefix,
+                                roleType: "assistant",
+                                content: `${output}`,
+                            },
+                        ],
+                    });
+                }
+                catch (error) {
+                    console.error("Error adding memory: ", error);
+                }
+            }
+            // Call the superclass's saveContext method
+            yield _super.saveContext.call(this, inputValues, outputValues);
+        });
+    }
+    /**
+     * Method that deletes the chat history from the Zep service.
+     * @returns Promise that resolves when the chat history has been deleted.
+     */
+    clear() {
+        const _super = Object.create(null, {
+            clear: { get: () => super.clear }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.zepClient.memory.delete(this.sessionId);
+            }
+            catch (error) {
+                console.error("Error deleting session: ", error);
+            }
+            // Clear the superclass's chat history
+            yield _super.clear.call(this);
+        });
+    }
+}
+exports.ZepMemory = ZepMemory;

package/dist/serialization/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./resources";
+export * from "./types";

package/dist/serialization/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./resources"), exports);
+__exportStar(require("./types"), exports);

package/dist/serialization/resources/document/client/addDocuments.d.ts

@@ -0,0 +1,15 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+import * as serializers from "../../../index";
+import * as Zep from "../../../../api/index";
+import * as core from "../../../../core";
+import { CreateDocumentRequest } from "../../../types/CreateDocumentRequest";
+export declare const Request: core.serialization.Schema<serializers.document.addDocuments.Request.Raw, Zep.CreateDocumentRequest[]>;
+export declare namespace Request {
+    type Raw = CreateDocumentRequest.Raw[];
+}
+export declare const Response: core.serialization.Schema<serializers.document.addDocuments.Response.Raw, string[]>;
+export declare namespace Response {
+    type Raw = string[];
+}

package/dist/serialization/resources/document/client/addDocuments.js

@@ -0,0 +1,33 @@
+"use strict";
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Response = exports.Request = void 0;
+const core = __importStar(require("../../../../core"));
+const CreateDocumentRequest_1 = require("../../../types/CreateDocumentRequest");
+exports.Request = core.serialization.list(CreateDocumentRequest_1.CreateDocumentRequest);
+exports.Response = core.serialization.list(core.serialization.string());

package/dist/serialization/resources/document/client/batchDeleteDocuments.d.ts

@@ -0,0 +1,9 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+import * as serializers from "../../../index";
+import * as core from "../../../../core";
+export declare const Request: core.serialization.Schema<serializers.document.batchDeleteDocuments.Request.Raw, string[]>;
+export declare namespace Request {
+    type Raw = string[];
+}