langchain 0.0.176 → 0.0.178

package/dist/retrievers/zep.js

@@ -44,6 +44,12 @@ export class ZepRetriever extends BaseRetriever {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "searchScope", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "searchType", {
             enumerable: true,
             configurable: true,
@@ -64,17 +70,18 @@ export class ZepRetriever extends BaseRetriever {
         });
         this.sessionId = config.sessionId;
         this.topK = config.topK;
+        this.searchScope = config.searchScope;
         this.searchType = config.searchType;
         this.mmrLambda = config.mmrLambda;
         this.filter = config.filter;
         this.zepClientPromise = ZepClient.init(config.url, config.apiKey);
     }
     /**
-     *  Converts an array of search results to an array of Document objects.
+     *  Converts an array of message search results to an array of Document objects.
      *  @param {MemorySearchResult[]} results - The array of search results.
      *  @returns {Document[]} An array of Document objects representing the search results.
      */
-    searchResultToDoc(results) {
+    searchMessageResultToDoc(results) {
         return results
             .filter((r) => r.message)
             .map(({ message: { content, metadata: messageMetadata } = {}, dist, ...rest }) => new Document({
@@ -82,6 +89,19 @@ export class ZepRetriever extends BaseRetriever {
             metadata: { score: dist, ...messageMetadata, ...rest },
         }));
     }
+    /**
+     *  Converts an array of summary search results to an array of Document objects.
+     *  @param {MemorySearchResult[]} results - The array of search results.
+     *  @returns {Document[]} An array of Document objects representing the search results.
+     */
+    searchSummaryResultToDoc(results) {
+        return results
+            .filter((r) => r.summary)
+            .map(({ summary: { content, metadata: summaryMetadata } = {}, dist, ...rest }) => new Document({
+            pageContent: content ?? "",
+            metadata: { score: dist, ...summaryMetadata, ...rest },
+        }));
+    }
     /**
      *  Retrieves the relevant documents based on the given query.
      *  @param {string} query - The query string.
@@ -91,6 +111,7 @@ export class ZepRetriever extends BaseRetriever {
         const payload = {
             text: query,
             metadata: this.filter,
+            search_scope: this.searchScope,
             search_type: this.searchType,
             mmr_lambda: this.mmrLambda,
         };
@@ -101,7 +122,9 @@ export class ZepRetriever extends BaseRetriever {
         }
         try {
             const results = await zepClient.memory.searchMemory(this.sessionId, payload, this.topK);
-            return this.searchResultToDoc(results);
+            return this.searchScope === "summary"
+                ? this.searchSummaryResultToDoc(results)
+                : this.searchMessageResultToDoc(results);
         }
         catch (error) {
             // eslint-disable-next-line no-instanceof/no-instanceof

package/dist/util/bedrock.d.ts

@@ -33,6 +33,8 @@ export interface BaseBedrockInput {
     stopSequences?: string[];
     /** Additional kwargs to pass to the model. */
     modelKwargs?: Record<string, unknown>;
+    /** Whether or not to stream responses */
+    streaming: boolean;
 }
 type Dict = {
     [key: string]: unknown;

package/dist/util/event-source-parse.cjs

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getMessages = exports.getLines = exports.getBytes = exports.EventStreamContentType = void 0;
+exports.convertEventStreamToIterableReadableDataStream = exports.getMessages = exports.getLines = exports.getBytes = exports.EventStreamContentType = void 0;
+const stream_js_1 = require("./stream.cjs");
 exports.EventStreamContentType = "text/event-stream";
 function isNodeJSReadable(x) {
     return x != null && typeof x === "object" && "on" in x;
@@ -199,6 +200,24 @@ function newMessage() {
         retry: undefined,
     };
 }
+function convertEventStreamToIterableReadableDataStream(stream) {
+    const dataStream = new ReadableStream({
+        async start(controller) {
+            const enqueueLine = getMessages((msg) => {
+                if (msg.data)
+                    controller.enqueue(msg.data);
+            });
+            const onLine = (line, fieldLength, flush) => {
+                enqueueLine(line, fieldLength, flush);
+                if (flush)
+                    controller.close();
+            };
+            await getBytes(stream, getLines(onLine));
+        },
+    });
+    return stream_js_1.IterableReadableStream.fromReadableStream(dataStream);
+}
+exports.convertEventStreamToIterableReadableDataStream = convertEventStreamToIterableReadableDataStream;
 function isEmpty(message) {
     return (message.data === "" &&
         message.event === "" &&

package/dist/util/event-source-parse.d.ts

@@ -1,3 +1,4 @@
+import { IterableReadableStream } from "./stream.js";
 export declare const EventStreamContentType = "text/event-stream";
 /**
  * Represents a message sent in an event stream
@@ -35,3 +36,4 @@ export declare function getLines(onLine: (line: Uint8Array, fieldLength: number,
  * @returns A function that should be called for each incoming line buffer.
  */
 export declare function getMessages(onMessage?: (msg: EventSourceMessage) => void, onId?: (id: string) => void, onRetry?: (retry: number) => void): (line: Uint8Array, fieldLength: number, flush?: boolean) => void;
+export declare function convertEventStreamToIterableReadableDataStream(stream: ReadableStream): IterableReadableStream<any>;

package/dist/util/event-source-parse.js

@@ -1,3 +1,4 @@
+import { IterableReadableStream } from "./stream.js";
 export const EventStreamContentType = "text/event-stream";
 function isNodeJSReadable(x) {
     return x != null && typeof x === "object" && "on" in x;
@@ -193,6 +194,23 @@ function newMessage() {
         retry: undefined,
     };
 }
+export function convertEventStreamToIterableReadableDataStream(stream) {
+    const dataStream = new ReadableStream({
+        async start(controller) {
+            const enqueueLine = getMessages((msg) => {
+                if (msg.data)
+                    controller.enqueue(msg.data);
+            });
+            const onLine = (line, fieldLength, flush) => {
+                enqueueLine(line, fieldLength, flush);
+                if (flush)
+                    controller.close();
+            };
+            await getBytes(stream, getLines(onLine));
+        },
+    });
+    return IterableReadableStream.fromReadableStream(dataStream);
+}
 function isEmpty(message) {
     return (message.data === "" &&
         message.event === "" &&

package/dist/util/iflytek_websocket_stream.cjs

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseWebSocketStream = void 0;
+/**
+ * [WebSocket](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket) with [Streams API](https://developer.mozilla.org/en-US/docs/Web/API/Streams_API)
+ *
+ * @see https://web.dev/websocketstream/
+ */
+class BaseWebSocketStream {
+    constructor(url, options = {}) {
+        Object.defineProperty(this, "url", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "connection", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "closed", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "close", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        if (options.signal?.aborted) {
+            throw new DOMException("This operation was aborted", "AbortError");
+        }
+        this.url = url;
+        const ws = this.openWebSocket(url, options);
+        const closeWithInfo = ({ code, reason } = {}) => ws.close(code, reason);
+        this.connection = new Promise((resolve, reject) => {
+            ws.onopen = () => {
+                resolve({
+                    readable: new ReadableStream({
+                        start(controller) {
+                            ws.onmessage = ({ data }) => controller.enqueue(data);
+                            ws.onerror = (e) => controller.error(e);
+                        },
+                        cancel: closeWithInfo,
+                    }),
+                    writable: new WritableStream({
+                        write(chunk) {
+                            ws.send(chunk);
+                        },
+                        abort() {
+                            ws.close();
+                        },
+                        close: closeWithInfo,
+                    }),
+                    protocol: ws.protocol,
+                    extensions: ws.extensions,
+                });
+                ws.removeEventListener("error", reject);
+            };
+            ws.addEventListener("error", reject);
+        });
+        this.closed = new Promise((resolve, reject) => {
+            ws.onclose = ({ code, reason }) => {
+                resolve({ code, reason });
+                ws.removeEventListener("error", reject);
+            };
+            ws.addEventListener("error", reject);
+        });
+        if (options.signal) {
+            // eslint-disable-next-line no-param-reassign
+            options.signal.onabort = () => ws.close();
+        }
+        this.close = closeWithInfo;
+    }
+}
+exports.BaseWebSocketStream = BaseWebSocketStream;

package/dist/util/iflytek_websocket_stream.d.ts

@@ -0,0 +1,27 @@
+export interface WebSocketConnection<T extends Uint8Array | string = Uint8Array | string> {
+    readable: ReadableStream<T>;
+    writable: WritableStream<T>;
+    protocol: string;
+    extensions: string;
+}
+export interface WebSocketCloseInfo {
+    code?: number;
+    reason?: string;
+}
+export interface WebSocketStreamOptions {
+    protocols?: string[];
+    signal?: AbortSignal;
+}
+/**
+ * [WebSocket](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket) with [Streams API](https://developer.mozilla.org/en-US/docs/Web/API/Streams_API)
+ *
+ * @see https://web.dev/websocketstream/
+ */
+export declare abstract class BaseWebSocketStream<T extends Uint8Array | string = Uint8Array | string> {
+    readonly url: string;
+    readonly connection: Promise<WebSocketConnection<T>>;
+    readonly closed: Promise<WebSocketCloseInfo>;
+    readonly close: (closeInfo?: WebSocketCloseInfo) => void;
+    constructor(url: string, options?: WebSocketStreamOptions);
+    abstract openWebSocket(url: string, options: WebSocketStreamOptions): WebSocket;
+}

package/dist/util/iflytek_websocket_stream.js

@@ -0,0 +1,77 @@
+/**
+ * [WebSocket](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket) with [Streams API](https://developer.mozilla.org/en-US/docs/Web/API/Streams_API)
+ *
+ * @see https://web.dev/websocketstream/
+ */
+export class BaseWebSocketStream {
+    constructor(url, options = {}) {
+        Object.defineProperty(this, "url", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "connection", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "closed", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "close", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        if (options.signal?.aborted) {
+            throw new DOMException("This operation was aborted", "AbortError");
+        }
+        this.url = url;
+        const ws = this.openWebSocket(url, options);
+        const closeWithInfo = ({ code, reason } = {}) => ws.close(code, reason);
+        this.connection = new Promise((resolve, reject) => {
+            ws.onopen = () => {
+                resolve({
+                    readable: new ReadableStream({
+                        start(controller) {
+                            ws.onmessage = ({ data }) => controller.enqueue(data);
+                            ws.onerror = (e) => controller.error(e);
+                        },
+                        cancel: closeWithInfo,
+                    }),
+                    writable: new WritableStream({
+                        write(chunk) {
+                            ws.send(chunk);
+                        },
+                        abort() {
+                            ws.close();
+                        },
+                        close: closeWithInfo,
+                    }),
+                    protocol: ws.protocol,
+                    extensions: ws.extensions,
+                });
+                ws.removeEventListener("error", reject);
+            };
+            ws.addEventListener("error", reject);
+        });
+        this.closed = new Promise((resolve, reject) => {
+            ws.onclose = ({ code, reason }) => {
+                resolve({ code, reason });
+                ws.removeEventListener("error", reject);
+            };
+            ws.addEventListener("error", reject);
+        });
+        if (options.signal) {
+            // eslint-disable-next-line no-param-reassign
+            options.signal.onabort = () => ws.close();
+        }
+        this.close = closeWithInfo;
+    }
+}

package/dist/util/llama_cpp.cjs

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLlamaSession = exports.createLlamaContext = exports.createLlamaModel = void 0;
+const node_llama_cpp_1 = require("node-llama-cpp");
+function createLlamaModel(inputs) {
+    const options = {
+        gpuLayers: inputs?.gpuLayers,
+        modelPath: inputs.modelPath,
+        useMlock: inputs?.useMlock,
+        useMmap: inputs?.useMmap,
+        vocabOnly: inputs?.vocabOnly,
+    };
+    return new node_llama_cpp_1.LlamaModel(options);
+}
+exports.createLlamaModel = createLlamaModel;
+function createLlamaContext(model, inputs) {
+    const options = {
+        batchSize: inputs?.batchSize,
+        contextSize: inputs?.contextSize,
+        embedding: inputs?.embedding,
+        f16Kv: inputs?.f16Kv,
+        logitsAll: inputs?.logitsAll,
+        model,
+        prependBos: inputs?.prependBos,
+        seed: inputs?.seed,
+        threads: inputs?.threads,
+    };
+    return new node_llama_cpp_1.LlamaContext(options);
+}
+exports.createLlamaContext = createLlamaContext;
+function createLlamaSession(context) {
+    return new node_llama_cpp_1.LlamaChatSession({ context });
+}
+exports.createLlamaSession = createLlamaSession;

package/dist/util/llama_cpp.d.ts

@@ -0,0 +1,46 @@
+import { LlamaModel, LlamaContext, LlamaChatSession } from "node-llama-cpp";
+/**
+ * Note that the modelPath is the only required parameter. For testing you
+ * can set this in the environment variable `LLAMA_PATH`.
+ */
+export interface LlamaBaseCppInputs {
+    /** Prompt processing batch size. */
+    batchSize?: number;
+    /** Text context size. */
+    contextSize?: number;
+    /** Embedding mode only. */
+    embedding?: boolean;
+    /** Use fp16 for KV cache. */
+    f16Kv?: boolean;
+    /** Number of layers to store in VRAM. */
+    gpuLayers?: number;
+    /** The llama_eval() call computes all logits, not just the last one. */
+    logitsAll?: boolean;
+    /** */
+    maxTokens?: number;
+    /** Path to the model on the filesystem. */
+    modelPath: string;
+    /** Add the begining of sentence token.  */
+    prependBos?: boolean;
+    /** If null, a random seed will be used. */
+    seed?: null | number;
+    /** The randomness of the responses, e.g. 0.1 deterministic, 1.5 creative, 0.8 balanced, 0 disables. */
+    temperature?: number;
+    /** Number of threads to use to evaluate tokens. */
+    threads?: number;
+    /** Trim whitespace from the end of the generated text Disabled by default. */
+    trimWhitespaceSuffix?: boolean;
+    /** Consider the n most likely tokens, where n is 1 to vocabulary size, 0 disables (uses full vocabulary). Note: only applies when `temperature` > 0. */
+    topK?: number;
+    /** Selects the smallest token set whose probability exceeds P, where P is between 0 - 1, 1 disables. Note: only applies when `temperature` > 0. */
+    topP?: number;
+    /** Force system to keep model in RAM. */
+    useMlock?: boolean;
+    /** Use mmap if possible. */
+    useMmap?: boolean;
+    /** Only load the vocabulary, no weights. */
+    vocabOnly?: boolean;
+}
+export declare function createLlamaModel(inputs: LlamaBaseCppInputs): LlamaModel;
+export declare function createLlamaContext(model: LlamaModel, inputs: LlamaBaseCppInputs): LlamaContext;
+export declare function createLlamaSession(context: LlamaContext): LlamaChatSession;

package/dist/util/llama_cpp.js

@@ -0,0 +1,28 @@
+import { LlamaModel, LlamaContext, LlamaChatSession } from "node-llama-cpp";
+export function createLlamaModel(inputs) {
+    const options = {
+        gpuLayers: inputs?.gpuLayers,
+        modelPath: inputs.modelPath,
+        useMlock: inputs?.useMlock,
+        useMmap: inputs?.useMmap,
+        vocabOnly: inputs?.vocabOnly,
+    };
+    return new LlamaModel(options);
+}
+export function createLlamaContext(model, inputs) {
+    const options = {
+        batchSize: inputs?.batchSize,
+        contextSize: inputs?.contextSize,
+        embedding: inputs?.embedding,
+        f16Kv: inputs?.f16Kv,
+        logitsAll: inputs?.logitsAll,
+        model,
+        prependBos: inputs?.prependBos,
+        seed: inputs?.seed,
+        threads: inputs?.threads,
+    };
+    return new LlamaContext(options);
+}
+export function createLlamaSession(context) {
+    return new LlamaChatSession({ context });
+}

package/dist/util/openai-format-fndef.cjs

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatFunctionDefinitions = void 0;
+function isAnyOfProp(prop) {
+    return (prop.anyOf !== undefined &&
+        Array.isArray(prop.anyOf));
+}
+// When OpenAI use functions in the prompt, they format them as TypeScript definitions rather than OpenAPI JSON schemas.
+// This function converts the JSON schemas into TypeScript definitions.
+function formatFunctionDefinitions(functions) {
+    const lines = ["namespace functions {", ""];
+    for (const f of functions) {
+        if (f.description) {
+            lines.push(`// ${f.description}`);
+        }
+        if (Object.keys(f.parameters.properties ?? {}).length > 0) {
+            lines.push(`type ${f.name} = (_: {`);
+            lines.push(formatObjectProperties(f.parameters, 0));
+            lines.push("}) => any;");
+        }
+        else {
+            lines.push(`type ${f.name} = () => any;`);
+        }
+        lines.push("");
+    }
+    lines.push("} // namespace functions");
+    return lines.join("\n");
+}
+exports.formatFunctionDefinitions = formatFunctionDefinitions;
+// Format just the properties of an object (not including the surrounding braces)
+function formatObjectProperties(obj, indent) {
+    const lines = [];
+    for (const [name, param] of Object.entries(obj.properties ?? {})) {
+        if (param.description && indent < 2) {
+            lines.push(`// ${param.description}`);
+        }
+        if (obj.required?.includes(name)) {
+            lines.push(`${name}: ${formatType(param, indent)},`);
+        }
+        else {
+            lines.push(`${name}?: ${formatType(param, indent)},`);
+        }
+    }
+    return lines.map((line) => " ".repeat(indent) + line).join("\n");
+}
+// Format a single property type
+function formatType(param, indent) {
+    if (isAnyOfProp(param)) {
+        return param.anyOf.map((v) => formatType(v, indent)).join(" | ");
+    }
+    switch (param.type) {
+        case "string":
+            if (param.enum) {
+                return param.enum.map((v) => `"${v}"`).join(" | ");
+            }
+            return "string";
+        case "number":
+            if (param.enum) {
+                return param.enum.map((v) => `${v}`).join(" | ");
+            }
+            return "number";
+        case "integer":
+            if (param.enum) {
+                return param.enum.map((v) => `${v}`).join(" | ");
+            }
+            return "number";
+        case "boolean":
+            return "boolean";
+        case "null":
+            return "null";
+        case "object":
+            return ["{", formatObjectProperties(param, indent + 2), "}"].join("\n");
+        case "array":
+            if (param.items) {
+                return `${formatType(param.items, indent)}[]`;
+            }
+            return "any[]";
+        default:
+            return "";
+    }
+}

package/dist/util/openai-format-fndef.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Formatting function definitions for calculating openai function defination token usage.
+ *
+ * https://github.com/hmarr/openai-chat-tokens/blob/main/src/functions.ts
+ * (c) 2023 Harry Marr
+ * MIT license
+ */
+import OpenAI from "openai";
+type OpenAIFunction = OpenAI.Chat.ChatCompletionCreateParams.Function;
+export interface FunctionDef extends Omit<OpenAIFunction, "parameters"> {
+    name: string;
+    description?: string;
+    parameters: ObjectProp;
+}
+interface ObjectProp {
+    type: "object";
+    properties?: {
+        [key: string]: Prop;
+    };
+    required?: string[];
+}
+interface AnyOfProp {
+    anyOf: Prop[];
+}
+type Prop = {
+    description?: string;
+} & (AnyOfProp | ObjectProp | {
+    type: "string";
+    enum?: string[];
+} | {
+    type: "number" | "integer";
+    minimum?: number;
+    maximum?: number;
+    enum?: number[];
+} | {
+    type: "boolean";
+} | {
+    type: "null";
+} | {
+    type: "array";
+    items?: Prop;
+});
+export declare function formatFunctionDefinitions(functions: FunctionDef[]): string;
+export {};

package/dist/util/openai-format-fndef.js

@@ -0,0 +1,77 @@
+function isAnyOfProp(prop) {
+    return (prop.anyOf !== undefined &&
+        Array.isArray(prop.anyOf));
+}
+// When OpenAI use functions in the prompt, they format them as TypeScript definitions rather than OpenAPI JSON schemas.
+// This function converts the JSON schemas into TypeScript definitions.
+export function formatFunctionDefinitions(functions) {
+    const lines = ["namespace functions {", ""];
+    for (const f of functions) {
+        if (f.description) {
+            lines.push(`// ${f.description}`);
+        }
+        if (Object.keys(f.parameters.properties ?? {}).length > 0) {
+            lines.push(`type ${f.name} = (_: {`);
+            lines.push(formatObjectProperties(f.parameters, 0));
+            lines.push("}) => any;");
+        }
+        else {
+            lines.push(`type ${f.name} = () => any;`);
+        }
+        lines.push("");
+    }
+    lines.push("} // namespace functions");
+    return lines.join("\n");
+}
+// Format just the properties of an object (not including the surrounding braces)
+function formatObjectProperties(obj, indent) {
+    const lines = [];
+    for (const [name, param] of Object.entries(obj.properties ?? {})) {
+        if (param.description && indent < 2) {
+            lines.push(`// ${param.description}`);
+        }
+        if (obj.required?.includes(name)) {
+            lines.push(`${name}: ${formatType(param, indent)},`);
+        }
+        else {
+            lines.push(`${name}?: ${formatType(param, indent)},`);
+        }
+    }
+    return lines.map((line) => " ".repeat(indent) + line).join("\n");
+}
+// Format a single property type
+function formatType(param, indent) {
+    if (isAnyOfProp(param)) {
+        return param.anyOf.map((v) => formatType(v, indent)).join(" | ");
+    }
+    switch (param.type) {
+        case "string":
+            if (param.enum) {
+                return param.enum.map((v) => `"${v}"`).join(" | ");
+            }
+            return "string";
+        case "number":
+            if (param.enum) {
+                return param.enum.map((v) => `${v}`).join(" | ");
+            }
+            return "number";
+        case "integer":
+            if (param.enum) {
+                return param.enum.map((v) => `${v}`).join(" | ");
+            }
+            return "number";
+        case "boolean":
+            return "boolean";
+        case "null":
+            return "null";
+        case "object":
+            return ["{", formatObjectProperties(param, indent + 2), "}"].join("\n");
+        case "array":
+            if (param.items) {
+                return `${formatType(param.items, indent)}[]`;
+            }
+            return "any[]";
+        default:
+            return "";
+    }
+}

package/dist/util/openapi.d.ts

@@ -7,7 +7,7 @@ export declare class OpenAPISpec {
     getParametersStrict(): Record<string, OpenAPIV3.ParameterObject | OpenAPIV3_1.ReferenceObject>;
     getSchemasStrict(): Record<string, OpenAPIV3_1.SchemaObject>;
     getRequestBodiesStrict(): Record<string, OpenAPIV3_1.ReferenceObject | OpenAPIV3_1.RequestBodyObject>;
-    getPathStrict(path: string): Omit<OpenAPIV3.PathItemObject<{}>, "servers" | "parameters"> & {
+    getPathStrict(path: string): Omit<OpenAPIV3.PathItemObject<{}>, "parameters" | "servers"> & {
         servers?: OpenAPIV3_1.ServerObject[] | undefined;
         parameters?: (OpenAPIV3.ParameterObject | OpenAPIV3_1.ReferenceObject)[] | undefined;
     } & {
@@ -59,7 +59,7 @@ export declare class OpenAPISpec {
         deprecated?: boolean | undefined;
         security?: OpenAPIV3.SecurityRequirementObject[] | undefined;
         servers?: OpenAPIV3.ServerObject[] | undefined;
-    }, "callbacks" | "servers" | "parameters" | "responses" | "requestBody"> & {
+    }, "callbacks" | "parameters" | "servers" | "responses" | "requestBody"> & {
         parameters?: (OpenAPIV3.ParameterObject | OpenAPIV3_1.ReferenceObject)[] | undefined;
         requestBody?: OpenAPIV3_1.ReferenceObject | OpenAPIV3_1.RequestBodyObject | undefined;
         responses?: OpenAPIV3_1.ResponsesObject | undefined;