@nocobase/plugin-ai 1.6.0-beta.17

package/dist/node_modules/@langchain/core/dist/load/index.cjs

@@ -0,0 +1,189 @@
+"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 __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.load = void 0;
+const serializable_js_1 = require("./serializable.cjs");
+const import_constants_js_1 = require("./import_constants.cjs");
+const coreImportMap = __importStar(require("./import_map.cjs"));
+const map_keys_js_1 = require("./map_keys.cjs");
+const env_js_1 = require("../utils/env.cjs");
+function combineAliasesAndInvert(constructor) {
+    const aliases = {};
+    for (
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    let current = constructor; current && current.prototype; current = Object.getPrototypeOf(current)) {
+        Object.assign(aliases, Reflect.get(current.prototype, "lc_aliases"));
+    }
+    return Object.entries(aliases).reduce((acc, [key, value]) => {
+        acc[value] = key;
+        return acc;
+    }, {});
+}
+async function reviver(value) {
+    const { optionalImportsMap = {}, optionalImportEntrypoints = [], importMap = {}, secretsMap = {}, path = ["$"], } = this;
+    const pathStr = path.join(".");
+    if (typeof value === "object" &&
+        value !== null &&
+        !Array.isArray(value) &&
+        "lc" in value &&
+        "type" in value &&
+        "id" in value &&
+        value.lc === 1 &&
+        value.type === "secret") {
+        const serialized = value;
+        const [key] = serialized.id;
+        if (key in secretsMap) {
+            return secretsMap[key];
+        }
+        else {
+            const secretValueInEnv = (0, env_js_1.getEnvironmentVariable)(key);
+            if (secretValueInEnv) {
+                return secretValueInEnv;
+            }
+            else {
+                throw new Error(`Missing key "${key}" for ${pathStr} in load(secretsMap={})`);
+            }
+        }
+    }
+    else if (typeof value === "object" &&
+        value !== null &&
+        !Array.isArray(value) &&
+        "lc" in value &&
+        "type" in value &&
+        "id" in value &&
+        value.lc === 1 &&
+        value.type === "not_implemented") {
+        const serialized = value;
+        const str = JSON.stringify(serialized);
+        throw new Error(`Trying to load an object that doesn't implement serialization: ${pathStr} -> ${str}`);
+    }
+    else if (typeof value === "object" &&
+        value !== null &&
+        !Array.isArray(value) &&
+        "lc" in value &&
+        "type" in value &&
+        "id" in value &&
+        "kwargs" in value &&
+        value.lc === 1) {
+        const serialized = value;
+        const str = JSON.stringify(serialized);
+        const [name, ...namespaceReverse] = serialized.id.slice().reverse();
+        const namespace = namespaceReverse.reverse();
+        const importMaps = { langchain_core: coreImportMap, langchain: importMap };
+        let module = null;
+        const optionalImportNamespaceAliases = [namespace.join("/")];
+        if (namespace[0] === "langchain_community") {
+            optionalImportNamespaceAliases.push(["langchain", ...namespace.slice(1)].join("/"));
+        }
+        const matchingNamespaceAlias = optionalImportNamespaceAliases.find((alias) => alias in optionalImportsMap);
+        if (import_constants_js_1.optionalImportEntrypoints
+            .concat(optionalImportEntrypoints)
+            .includes(namespace.join("/")) ||
+            matchingNamespaceAlias) {
+            if (matchingNamespaceAlias !== undefined) {
+                module = await optionalImportsMap[matchingNamespaceAlias];
+            }
+            else {
+                throw new Error(`Missing key "${namespace.join("/")}" for ${pathStr} in load(optionalImportsMap={})`);
+            }
+        }
+        else {
+            let finalImportMap;
+            // Currently, we only support langchain and langchain_core imports.
+            if (namespace[0] === "langchain" || namespace[0] === "langchain_core") {
+                finalImportMap = importMaps[namespace[0]];
+                namespace.shift();
+            }
+            else {
+                throw new Error(`Invalid namespace: ${pathStr} -> ${str}`);
+            }
+            // The root namespace "langchain" is not a valid import.
+            if (namespace.length === 0) {
+                throw new Error(`Invalid namespace: ${pathStr} -> ${str}`);
+            }
+            // Find the longest matching namespace.
+            let importMapKey;
+            do {
+                importMapKey = namespace.join("__");
+                if (importMapKey in finalImportMap) {
+                    break;
+                }
+                else {
+                    namespace.pop();
+                }
+            } while (namespace.length > 0);
+            // If no matching namespace is found, throw an error.
+            if (importMapKey in finalImportMap) {
+                module = finalImportMap[importMapKey];
+            }
+        }
+        if (typeof module !== "object" || module === null) {
+            throw new Error(`Invalid namespace: ${pathStr} -> ${str}`);
+        }
+        // Extract the builder from the import map.
+        const builder = 
+        // look for a named export with the same name as the class
+        module[name] ??
+            // look for an export with a lc_name property matching the class name
+            // this is necessary for classes that are minified
+            Object.values(module).find((v) => typeof v === "function" &&
+                (0, serializable_js_1.get_lc_unique_name)(v) === name);
+        if (typeof builder !== "function") {
+            throw new Error(`Invalid identifer: ${pathStr} -> ${str}`);
+        }
+        // Recurse on the arguments, which may be serialized objects themselves
+        const kwargs = await reviver.call({ ...this, path: [...path, "kwargs"] }, serialized.kwargs);
+        // Construct the object
+        if (serialized.type === "constructor") {
+            // eslint-disable-next-line new-cap, @typescript-eslint/no-explicit-any
+            const instance = new builder((0, map_keys_js_1.mapKeys)(kwargs, map_keys_js_1.keyFromJson, combineAliasesAndInvert(builder)));
+            // Minification in severless/edge runtimes will mange the
+            // name of classes presented in traces. As the names in import map
+            // are present as-is even with minification, use these names instead
+            Object.defineProperty(instance.constructor, "name", { value: name });
+            return instance;
+        }
+        else {
+            throw new Error(`Invalid type: ${pathStr} -> ${str}`);
+        }
+    }
+    else if (typeof value === "object" && value !== null) {
+        if (Array.isArray(value)) {
+            return Promise.all(value.map((v, i) => reviver.call({ ...this, path: [...path, `${i}`] }, v)));
+        }
+        else {
+            return Object.fromEntries(await Promise.all(Object.entries(value).map(async ([key, value]) => [
+                key,
+                await reviver.call({ ...this, path: [...path, key] }, value),
+            ])));
+        }
+    }
+    return value;
+}
+async function load(text, mappings) {
+    const json = JSON.parse(text);
+    return reviver.call({ ...mappings }, json);
+}
+exports.load = load;

package/dist/node_modules/@langchain/core/dist/load/index.d.ts

@@ -0,0 +1,7 @@
+import type { OptionalImportMap, SecretMap } from "./import_type.js";
+export declare function load<T>(text: string, mappings?: {
+    secretsMap?: SecretMap;
+    optionalImportsMap?: OptionalImportMap;
+    optionalImportEntrypoints?: string[];
+    importMap?: Record<string, unknown>;
+}): Promise<T>;

package/dist/node_modules/@langchain/core/dist/load/index.js

@@ -0,0 +1,162 @@
+import { get_lc_unique_name, } from "./serializable.js";
+import { optionalImportEntrypoints as defaultOptionalImportEntrypoints } from "./import_constants.js";
+import * as coreImportMap from "./import_map.js";
+import { keyFromJson, mapKeys } from "./map_keys.js";
+import { getEnvironmentVariable } from "../utils/env.js";
+function combineAliasesAndInvert(constructor) {
+    const aliases = {};
+    for (
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    let current = constructor; current && current.prototype; current = Object.getPrototypeOf(current)) {
+        Object.assign(aliases, Reflect.get(current.prototype, "lc_aliases"));
+    }
+    return Object.entries(aliases).reduce((acc, [key, value]) => {
+        acc[value] = key;
+        return acc;
+    }, {});
+}
+async function reviver(value) {
+    const { optionalImportsMap = {}, optionalImportEntrypoints = [], importMap = {}, secretsMap = {}, path = ["$"], } = this;
+    const pathStr = path.join(".");
+    if (typeof value === "object" &&
+        value !== null &&
+        !Array.isArray(value) &&
+        "lc" in value &&
+        "type" in value &&
+        "id" in value &&
+        value.lc === 1 &&
+        value.type === "secret") {
+        const serialized = value;
+        const [key] = serialized.id;
+        if (key in secretsMap) {
+            return secretsMap[key];
+        }
+        else {
+            const secretValueInEnv = getEnvironmentVariable(key);
+            if (secretValueInEnv) {
+                return secretValueInEnv;
+            }
+            else {
+                throw new Error(`Missing key "${key}" for ${pathStr} in load(secretsMap={})`);
+            }
+        }
+    }
+    else if (typeof value === "object" &&
+        value !== null &&
+        !Array.isArray(value) &&
+        "lc" in value &&
+        "type" in value &&
+        "id" in value &&
+        value.lc === 1 &&
+        value.type === "not_implemented") {
+        const serialized = value;
+        const str = JSON.stringify(serialized);
+        throw new Error(`Trying to load an object that doesn't implement serialization: ${pathStr} -> ${str}`);
+    }
+    else if (typeof value === "object" &&
+        value !== null &&
+        !Array.isArray(value) &&
+        "lc" in value &&
+        "type" in value &&
+        "id" in value &&
+        "kwargs" in value &&
+        value.lc === 1) {
+        const serialized = value;
+        const str = JSON.stringify(serialized);
+        const [name, ...namespaceReverse] = serialized.id.slice().reverse();
+        const namespace = namespaceReverse.reverse();
+        const importMaps = { langchain_core: coreImportMap, langchain: importMap };
+        let module = null;
+        const optionalImportNamespaceAliases = [namespace.join("/")];
+        if (namespace[0] === "langchain_community") {
+            optionalImportNamespaceAliases.push(["langchain", ...namespace.slice(1)].join("/"));
+        }
+        const matchingNamespaceAlias = optionalImportNamespaceAliases.find((alias) => alias in optionalImportsMap);
+        if (defaultOptionalImportEntrypoints
+            .concat(optionalImportEntrypoints)
+            .includes(namespace.join("/")) ||
+            matchingNamespaceAlias) {
+            if (matchingNamespaceAlias !== undefined) {
+                module = await optionalImportsMap[matchingNamespaceAlias];
+            }
+            else {
+                throw new Error(`Missing key "${namespace.join("/")}" for ${pathStr} in load(optionalImportsMap={})`);
+            }
+        }
+        else {
+            let finalImportMap;
+            // Currently, we only support langchain and langchain_core imports.
+            if (namespace[0] === "langchain" || namespace[0] === "langchain_core") {
+                finalImportMap = importMaps[namespace[0]];
+                namespace.shift();
+            }
+            else {
+                throw new Error(`Invalid namespace: ${pathStr} -> ${str}`);
+            }
+            // The root namespace "langchain" is not a valid import.
+            if (namespace.length === 0) {
+                throw new Error(`Invalid namespace: ${pathStr} -> ${str}`);
+            }
+            // Find the longest matching namespace.
+            let importMapKey;
+            do {
+                importMapKey = namespace.join("__");
+                if (importMapKey in finalImportMap) {
+                    break;
+                }
+                else {
+                    namespace.pop();
+                }
+            } while (namespace.length > 0);
+            // If no matching namespace is found, throw an error.
+            if (importMapKey in finalImportMap) {
+                module = finalImportMap[importMapKey];
+            }
+        }
+        if (typeof module !== "object" || module === null) {
+            throw new Error(`Invalid namespace: ${pathStr} -> ${str}`);
+        }
+        // Extract the builder from the import map.
+        const builder = 
+        // look for a named export with the same name as the class
+        module[name] ??
+            // look for an export with a lc_name property matching the class name
+            // this is necessary for classes that are minified
+            Object.values(module).find((v) => typeof v === "function" &&
+                get_lc_unique_name(v) === name);
+        if (typeof builder !== "function") {
+            throw new Error(`Invalid identifer: ${pathStr} -> ${str}`);
+        }
+        // Recurse on the arguments, which may be serialized objects themselves
+        const kwargs = await reviver.call({ ...this, path: [...path, "kwargs"] }, serialized.kwargs);
+        // Construct the object
+        if (serialized.type === "constructor") {
+            // eslint-disable-next-line new-cap, @typescript-eslint/no-explicit-any
+            const instance = new builder(mapKeys(kwargs, keyFromJson, combineAliasesAndInvert(builder)));
+            // Minification in severless/edge runtimes will mange the
+            // name of classes presented in traces. As the names in import map
+            // are present as-is even with minification, use these names instead
+            Object.defineProperty(instance.constructor, "name", { value: name });
+            return instance;
+        }
+        else {
+            throw new Error(`Invalid type: ${pathStr} -> ${str}`);
+        }
+    }
+    else if (typeof value === "object" && value !== null) {
+        if (Array.isArray(value)) {
+            return Promise.all(value.map((v, i) => reviver.call({ ...this, path: [...path, `${i}`] }, v)));
+        }
+        else {
+            return Object.fromEntries(await Promise.all(Object.entries(value).map(async ([key, value]) => [
+                key,
+                await reviver.call({ ...this, path: [...path, key] }, value),
+            ])));
+        }
+    }
+    return value;
+}
+export async function load(text, mappings) {
+    const json = JSON.parse(text);
+    return reviver.call({ ...mappings }, json);
+}

package/dist/node_modules/@langchain/core/dist/load/map_keys.cjs

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapKeys = exports.keyFromJson = exports.keyToJson = void 0;
+const decamelize_1 = __importDefault(require("decamelize"));
+const camelcase_1 = __importDefault(require("camelcase"));
+function keyToJson(key, map) {
+    return map?.[key] || (0, decamelize_1.default)(key);
+}
+exports.keyToJson = keyToJson;
+function keyFromJson(key, map) {
+    return map?.[key] || (0, camelcase_1.default)(key);
+}
+exports.keyFromJson = keyFromJson;
+function mapKeys(fields, mapper, map) {
+    const mapped = {};
+    for (const key in fields) {
+        if (Object.hasOwn(fields, key)) {
+            mapped[mapper(key, map)] = fields[key];
+        }
+    }
+    return mapped;
+}
+exports.mapKeys = mapKeys;

package/dist/node_modules/@langchain/core/dist/load/map_keys.d.ts

@@ -0,0 +1,9 @@
+export interface SerializedFields {
+    [key: string]: any;
+}
+export interface SerializedKeyAlias {
+    [key: string]: string;
+}
+export declare function keyToJson(key: string, map?: SerializedKeyAlias): string;
+export declare function keyFromJson(key: string, map?: SerializedKeyAlias): string;
+export declare function mapKeys(fields: SerializedFields, mapper: typeof keyToJson, map?: SerializedKeyAlias): SerializedFields;

package/dist/node_modules/@langchain/core/dist/load/map_keys.js

@@ -0,0 +1,17 @@
+import snakeCase from "decamelize";
+import camelCase from "camelcase";
+export function keyToJson(key, map) {
+    return map?.[key] || snakeCase(key);
+}
+export function keyFromJson(key, map) {
+    return map?.[key] || camelCase(key);
+}
+export function mapKeys(fields, mapper, map) {
+    const mapped = {};
+    for (const key in fields) {
+        if (Object.hasOwn(fields, key)) {
+            mapped[mapper(key, map)] = fields[key];
+        }
+    }
+    return mapped;
+}

package/dist/node_modules/@langchain/core/dist/load/serializable.cjs

@@ -0,0 +1,192 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Serializable = exports.get_lc_unique_name = void 0;
+const map_keys_js_1 = require("./map_keys.cjs");
+function shallowCopy(obj) {
+    return Array.isArray(obj) ? [...obj] : { ...obj };
+}
+function replaceSecrets(root, secretsMap) {
+    const result = shallowCopy(root);
+    for (const [path, secretId] of Object.entries(secretsMap)) {
+        const [last, ...partsReverse] = path.split(".").reverse();
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let current = result;
+        for (const part of partsReverse.reverse()) {
+            if (current[part] === undefined) {
+                break;
+            }
+            current[part] = shallowCopy(current[part]);
+            current = current[part];
+        }
+        if (current[last] !== undefined) {
+            current[last] = {
+                lc: 1,
+                type: "secret",
+                id: [secretId],
+            };
+        }
+    }
+    return result;
+}
+/**
+ * Get a unique name for the module, rather than parent class implementations.
+ * Should not be subclassed, subclass lc_name above instead.
+ */
+function get_lc_unique_name(
+// eslint-disable-next-line @typescript-eslint/no-use-before-define
+serializableClass) {
+    // "super" here would refer to the parent class of Serializable,
+    // when we want the parent class of the module actually calling this method.
+    const parentClass = Object.getPrototypeOf(serializableClass);
+    const lcNameIsSubclassed = typeof serializableClass.lc_name === "function" &&
+        (typeof parentClass.lc_name !== "function" ||
+            serializableClass.lc_name() !== parentClass.lc_name());
+    if (lcNameIsSubclassed) {
+        return serializableClass.lc_name();
+    }
+    else {
+        return serializableClass.name;
+    }
+}
+exports.get_lc_unique_name = get_lc_unique_name;
+class Serializable {
+    /**
+     * The name of the serializable. Override to provide an alias or
+     * to preserve the serialized module name in minified environments.
+     *
+     * Implemented as a static method to support loading logic.
+     */
+    static lc_name() {
+        return this.name;
+    }
+    /**
+     * The final serialized identifier for the module.
+     */
+    get lc_id() {
+        return [
+            ...this.lc_namespace,
+            get_lc_unique_name(this.constructor),
+        ];
+    }
+    /**
+     * A map of secrets, which will be omitted from serialization.
+     * Keys are paths to the secret in constructor args, e.g. "foo.bar.baz".
+     * Values are the secret ids, which will be used when deserializing.
+     */
+    get lc_secrets() {
+        return undefined;
+    }
+    /**
+     * A map of additional attributes to merge with constructor args.
+     * Keys are the attribute names, e.g. "foo".
+     * Values are the attribute values, which will be serialized.
+     * These attributes need to be accepted by the constructor as arguments.
+     */
+    get lc_attributes() {
+        return undefined;
+    }
+    /**
+     * A map of aliases for constructor args.
+     * Keys are the attribute names, e.g. "foo".
+     * Values are the alias that will replace the key in serialization.
+     * This is used to eg. make argument names match Python.
+     */
+    get lc_aliases() {
+        return undefined;
+    }
+    /**
+     * A manual list of keys that should be serialized.
+     * If not overridden, all fields passed into the constructor will be serialized.
+     */
+    get lc_serializable_keys() {
+        return undefined;
+    }
+    constructor(kwargs, ..._args) {
+        Object.defineProperty(this, "lc_serializable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "lc_kwargs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        if (this.lc_serializable_keys !== undefined) {
+            this.lc_kwargs = Object.fromEntries(Object.entries(kwargs || {}).filter(([key]) => this.lc_serializable_keys?.includes(key)));
+        }
+        else {
+            this.lc_kwargs = kwargs ?? {};
+        }
+    }
+    toJSON() {
+        if (!this.lc_serializable) {
+            return this.toJSONNotImplemented();
+        }
+        if (
+        // eslint-disable-next-line no-instanceof/no-instanceof
+        this.lc_kwargs instanceof Serializable ||
+            typeof this.lc_kwargs !== "object" ||
+            Array.isArray(this.lc_kwargs)) {
+            // We do not support serialization of classes with arg not a POJO
+            // I'm aware the check above isn't as strict as it could be
+            return this.toJSONNotImplemented();
+        }
+        const aliases = {};
+        const secrets = {};
+        const kwargs = Object.keys(this.lc_kwargs).reduce((acc, key) => {
+            acc[key] = key in this ? this[key] : this.lc_kwargs[key];
+            return acc;
+        }, {});
+        // get secrets, attributes and aliases from all superclasses
+        for (
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        let current = Object.getPrototypeOf(this); current; current = Object.getPrototypeOf(current)) {
+            Object.assign(aliases, Reflect.get(current, "lc_aliases", this));
+            Object.assign(secrets, Reflect.get(current, "lc_secrets", this));
+            Object.assign(kwargs, Reflect.get(current, "lc_attributes", this));
+        }
+        // include all secrets used, even if not in kwargs,
+        // will be replaced with sentinel value in replaceSecrets
+        Object.keys(secrets).forEach((keyPath) => {
+            // eslint-disable-next-line @typescript-eslint/no-this-alias, @typescript-eslint/no-explicit-any
+            let read = this;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            let write = kwargs;
+            const [last, ...partsReverse] = keyPath.split(".").reverse();
+            for (const key of partsReverse.reverse()) {
+                if (!(key in read) || read[key] === undefined)
+                    return;
+                if (!(key in write) || write[key] === undefined) {
+                    if (typeof read[key] === "object" && read[key] != null) {
+                        write[key] = {};
+                    }
+                    else if (Array.isArray(read[key])) {
+                        write[key] = [];
+                    }
+                }
+                read = read[key];
+                write = write[key];
+            }
+            if (last in read && read[last] !== undefined) {
+                write[last] = write[last] || read[last];
+            }
+        });
+        return {
+            lc: 1,
+            type: "constructor",
+            id: this.lc_id,
+            kwargs: (0, map_keys_js_1.mapKeys)(Object.keys(secrets).length ? replaceSecrets(kwargs, secrets) : kwargs, map_keys_js_1.keyToJson, aliases),
+        };
+    }
+    toJSONNotImplemented() {
+        return {
+            lc: 1,
+            type: "not_implemented",
+            id: this.lc_id,
+        };
+    }
+}
+exports.Serializable = Serializable;

package/dist/node_modules/@langchain/core/dist/load/serializable.d.ts

@@ -0,0 +1,76 @@
+import { type SerializedFields } from "./map_keys.js";
+export interface BaseSerialized<T extends string> {
+    lc: number;
+    type: T;
+    id: string[];
+    name?: string;
+    graph?: Record<string, any>;
+}
+export interface SerializedConstructor extends BaseSerialized<"constructor"> {
+    kwargs: SerializedFields;
+}
+export interface SerializedSecret extends BaseSerialized<"secret"> {
+}
+export interface SerializedNotImplemented extends BaseSerialized<"not_implemented"> {
+}
+export type Serialized = SerializedConstructor | SerializedSecret | SerializedNotImplemented;
+/**
+ * Get a unique name for the module, rather than parent class implementations.
+ * Should not be subclassed, subclass lc_name above instead.
+ */
+export declare function get_lc_unique_name(serializableClass: typeof Serializable): string;
+export interface SerializableInterface {
+    get lc_id(): string[];
+}
+export declare abstract class Serializable implements SerializableInterface {
+    lc_serializable: boolean;
+    lc_kwargs: SerializedFields;
+    /**
+     * A path to the module that contains the class, eg. ["langchain", "llms"]
+     * Usually should be the same as the entrypoint the class is exported from.
+     */
+    abstract lc_namespace: string[];
+    /**
+     * The name of the serializable. Override to provide an alias or
+     * to preserve the serialized module name in minified environments.
+     *
+     * Implemented as a static method to support loading logic.
+     */
+    static lc_name(): string;
+    /**
+     * The final serialized identifier for the module.
+     */
+    get lc_id(): string[];
+    /**
+     * A map of secrets, which will be omitted from serialization.
+     * Keys are paths to the secret in constructor args, e.g. "foo.bar.baz".
+     * Values are the secret ids, which will be used when deserializing.
+     */
+    get lc_secrets(): {
+        [key: string]: string;
+    } | undefined;
+    /**
+     * A map of additional attributes to merge with constructor args.
+     * Keys are the attribute names, e.g. "foo".
+     * Values are the attribute values, which will be serialized.
+     * These attributes need to be accepted by the constructor as arguments.
+     */
+    get lc_attributes(): SerializedFields | undefined;
+    /**
+     * A map of aliases for constructor args.
+     * Keys are the attribute names, e.g. "foo".
+     * Values are the alias that will replace the key in serialization.
+     * This is used to eg. make argument names match Python.
+     */
+    get lc_aliases(): {
+        [key: string]: string;
+    } | undefined;
+    /**
+     * A manual list of keys that should be serialized.
+     * If not overridden, all fields passed into the constructor will be serialized.
+     */
+    get lc_serializable_keys(): string[] | undefined;
+    constructor(kwargs?: SerializedFields, ..._args: never[]);
+    toJSON(): Serialized;
+    toJSONNotImplemented(): SerializedNotImplemented;
+}