langchain 0.0.131 → 0.0.132

package/dist/chains/openai_functions/tagging.cjs

@@ -5,6 +5,12 @@ const zod_to_json_schema_1 = require("zod-to-json-schema");
 const prompt_js_1 = require("../../prompts/prompt.cjs");
 const openai_functions_js_1 = require("../../output_parsers/openai_functions.cjs");
 const llm_chain_js_1 = require("../llm_chain.cjs");
+/**
+ * Function that returns an array of tagging functions. These functions
+ * are used to extract relevant information from a passage.
+ * @param schema The schema defining the structure of function parameters.
+ * @returns An array of tagging functions.
+ */
 function getTaggingFunctions(schema) {
     return [
         {
@@ -19,6 +25,15 @@ const TAGGING_TEMPLATE = `Extract the desired information from the following pas
 Passage:
 {input}
 `;
+/**
+ * Function that creates a tagging chain using the provided schema,
+ * LLM, and options. It constructs the LLM with the necessary
+ * functions, prompt, output parser, and tags.
+ * @param schema The schema defining the structure of function parameters.
+ * @param llm LLM to use in the chain. Must support OpenAI function calling.
+ * @param options Options for creating the tagging chain.
+ * @returns A new instance of LLMChain configured for tagging.
+ */
 function createTaggingChain(schema, llm, options = {}) {
     const { prompt = prompt_js_1.PromptTemplate.fromTemplate(TAGGING_TEMPLATE), ...rest } = options;
     const functions = getTaggingFunctions(schema);
@@ -33,6 +48,15 @@ function createTaggingChain(schema, llm, options = {}) {
     });
 }
 exports.createTaggingChain = createTaggingChain;
+/**
+ * Function that creates a tagging chain from a Zod schema. It converts
+ * the Zod schema to a JSON schema using the zodToJsonSchema function and
+ * then calls createTaggingChain with the converted schema.
+ * @param schema The Zod schema which extracted data should match.
+ * @param llm LLM to use in the chain. Must support OpenAI function calling.
+ * @param options Options for creating the tagging chain.
+ * @returns A new instance of LLMChain configured for tagging.
+ */
 function createTaggingChainFromZod(
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 schema, llm, options) {

package/dist/chains/openai_functions/tagging.d.ts

@@ -3,8 +3,29 @@ import { ChatOpenAI } from "../../chat_models/openai.js";
 import { PromptTemplate } from "../../prompts/prompt.js";
 import { FunctionParameters } from "../../output_parsers/openai_functions.js";
 import { LLMChain, LLMChainInput } from "../llm_chain.js";
+/**
+ * Type representing the options for creating a tagging chain.
+ */
 export type TaggingChainOptions = {
     prompt?: PromptTemplate;
 } & Omit<LLMChainInput<object>, "prompt" | "llm">;
+/**
+ * Function that creates a tagging chain using the provided schema,
+ * LLM, and options. It constructs the LLM with the necessary
+ * functions, prompt, output parser, and tags.
+ * @param schema The schema defining the structure of function parameters.
+ * @param llm LLM to use in the chain. Must support OpenAI function calling.
+ * @param options Options for creating the tagging chain.
+ * @returns A new instance of LLMChain configured for tagging.
+ */
 export declare function createTaggingChain(schema: FunctionParameters, llm: ChatOpenAI, options?: TaggingChainOptions): LLMChain<object, ChatOpenAI>;
+/**
+ * Function that creates a tagging chain from a Zod schema. It converts
+ * the Zod schema to a JSON schema using the zodToJsonSchema function and
+ * then calls createTaggingChain with the converted schema.
+ * @param schema The Zod schema which extracted data should match.
+ * @param llm LLM to use in the chain. Must support OpenAI function calling.
+ * @param options Options for creating the tagging chain.
+ * @returns A new instance of LLMChain configured for tagging.
+ */
 export declare function createTaggingChainFromZod(schema: z.ZodObject<any, any, any, any>, llm: ChatOpenAI, options?: TaggingChainOptions): LLMChain<object, ChatOpenAI>;

package/dist/chains/openai_functions/tagging.js

@@ -2,6 +2,12 @@ import { zodToJsonSchema } from "zod-to-json-schema";
 import { PromptTemplate } from "../../prompts/prompt.js";
 import { JsonOutputFunctionsParser, } from "../../output_parsers/openai_functions.js";
 import { LLMChain } from "../llm_chain.js";
+/**
+ * Function that returns an array of tagging functions. These functions
+ * are used to extract relevant information from a passage.
+ * @param schema The schema defining the structure of function parameters.
+ * @returns An array of tagging functions.
+ */
 function getTaggingFunctions(schema) {
     return [
         {
@@ -16,6 +22,15 @@ const TAGGING_TEMPLATE = `Extract the desired information from the following pas
 Passage:
 {input}
 `;
+/**
+ * Function that creates a tagging chain using the provided schema,
+ * LLM, and options. It constructs the LLM with the necessary
+ * functions, prompt, output parser, and tags.
+ * @param schema The schema defining the structure of function parameters.
+ * @param llm LLM to use in the chain. Must support OpenAI function calling.
+ * @param options Options for creating the tagging chain.
+ * @returns A new instance of LLMChain configured for tagging.
+ */
 export function createTaggingChain(schema, llm, options = {}) {
     const { prompt = PromptTemplate.fromTemplate(TAGGING_TEMPLATE), ...rest } = options;
     const functions = getTaggingFunctions(schema);
@@ -29,6 +44,15 @@ export function createTaggingChain(schema, llm, options = {}) {
         ...rest,
     });
 }
+/**
+ * Function that creates a tagging chain from a Zod schema. It converts
+ * the Zod schema to a JSON schema using the zodToJsonSchema function and
+ * then calls createTaggingChain with the converted schema.
+ * @param schema The Zod schema which extracted data should match.
+ * @param llm LLM to use in the chain. Must support OpenAI function calling.
+ * @param options Options for creating the tagging chain.
+ * @returns A new instance of LLMChain configured for tagging.
+ */
 export function createTaggingChainFromZod(
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 schema, llm, options) {

package/dist/chains/openai_moderation.cjs

@@ -9,6 +9,11 @@ const base_js_1 = require("./base.cjs");
 const axios_fetch_adapter_js_1 = __importDefault(require("../util/axios-fetch-adapter.cjs"));
 const async_caller_js_1 = require("../util/async_caller.cjs");
 const env_js_1 = require("../util/env.cjs");
+/**
+ * Class representing a chain for moderating text using the OpenAI
+ * Moderation API. It extends the BaseChain class and implements the
+ * OpenAIModerationChainInput interface.
+ */
 class OpenAIModerationChain extends base_js_1.BaseChain {
     static lc_name() {
         return "OpenAIModerationChain";

package/dist/chains/openai_moderation.d.ts

@@ -2,12 +2,20 @@ import { Configuration, OpenAIApi, ConfigurationParameters, CreateModerationResp
 import { BaseChain, ChainInputs } from "./base.js";
 import { ChainValues } from "../schema/index.js";
 import { AsyncCaller, AsyncCallerParams } from "../util/async_caller.js";
+/**
+ * Interface for the input parameters of the OpenAIModerationChain class.
+ */
 export interface OpenAIModerationChainInput extends ChainInputs, AsyncCallerParams {
     openAIApiKey?: string;
     openAIOrganization?: string;
     throwError?: boolean;
     configuration?: ConfigurationParameters;
 }
+/**
+ * Class representing a chain for moderating text using the OpenAI
+ * Moderation API. It extends the BaseChain class and implements the
+ * OpenAIModerationChainInput interface.
+ */
 export declare class OpenAIModerationChain extends BaseChain implements OpenAIModerationChainInput {
     static lc_name(): string;
     get lc_secrets(): {

package/dist/chains/openai_moderation.js

@@ -3,6 +3,11 @@ import { BaseChain } from "./base.js";
 import fetchAdapter from "../util/axios-fetch-adapter.js";
 import { AsyncCaller } from "../util/async_caller.js";
 import { getEnvironmentVariable } from "../util/env.js";
+/**
+ * Class representing a chain for moderating text using the OpenAI
+ * Moderation API. It extends the BaseChain class and implements the
+ * OpenAIModerationChainInput interface.
+ */
 export class OpenAIModerationChain extends BaseChain {
     static lc_name() {
         return "OpenAIModerationChain";

package/dist/chains/query_constructor/index.cjs

@@ -24,6 +24,10 @@ const queryInputSchema = /* #__PURE__ */ zod_1.z.object({
         .optional()
         .describe("logical condition statement for filtering documents"),
 });
+/**
+ * A class that extends AsymmetricStructuredOutputParser to parse
+ * structured query output.
+ */
 class StructuredQueryOutputParser extends structured_js_1.AsymmetricStructuredOutputParser {
     constructor(fields) {
         super({ ...fields, inputSchema: queryInputSchema });
@@ -42,6 +46,12 @@ class StructuredQueryOutputParser extends structured_js_1.AsymmetricStructuredOu
         const { allowedComparators, allowedOperators } = fields;
         this.queryTransformer = new parser_js_1.QueryTransformer(allowedComparators, allowedOperators);
     }
+    /**
+     * Processes the output of a structured query.
+     * @param query The query string.
+     * @param filter The filter condition.
+     * @returns A Promise that resolves to a StructuredQuery instance.
+     */
     async outputProcessor({ query, filter, }) {
         let myQuery = query;
         if (myQuery.length === 0) {
@@ -55,6 +65,13 @@ class StructuredQueryOutputParser extends structured_js_1.AsymmetricStructuredOu
             return new ir_js_1.StructuredQuery(query, parsedFilter);
         }
     }
+    /**
+     * Creates a new StructuredQueryOutputParser instance from the provided
+     * components.
+     * @param allowedComparators An array of allowed Comparator instances.
+     * @param allowedOperators An array of allowed Operator instances.
+     * @returns A new StructuredQueryOutputParser instance.
+     */
     static fromComponents(allowedComparators = [], allowedOperators = []) {
         return new StructuredQueryOutputParser({
             allowedComparators,

package/dist/chains/query_constructor/index.d.ts

@@ -19,6 +19,10 @@ declare const queryInputSchema: z.ZodObject<{
     query: string;
     filter?: string | undefined;
 }>;
+/**
+ * A class that extends AsymmetricStructuredOutputParser to parse
+ * structured query output.
+ */
 export declare class StructuredQueryOutputParser extends AsymmetricStructuredOutputParser<typeof queryInputSchema, StructuredQuery> {
     lc_namespace: string[];
     queryTransformer: QueryTransformer;
@@ -26,10 +30,26 @@ export declare class StructuredQueryOutputParser extends AsymmetricStructuredOut
         allowedComparators: Comparator[];
         allowedOperators: Operator[];
     });
+    /**
+     * Processes the output of a structured query.
+     * @param query The query string.
+     * @param filter The filter condition.
+     * @returns A Promise that resolves to a StructuredQuery instance.
+     */
     outputProcessor({ query, filter, }: z.infer<typeof queryInputSchema>): Promise<StructuredQuery>;
+    /**
+     * Creates a new StructuredQueryOutputParser instance from the provided
+     * components.
+     * @param allowedComparators An array of allowed Comparator instances.
+     * @param allowedOperators An array of allowed Operator instances.
+     * @returns A new StructuredQueryOutputParser instance.
+     */
     static fromComponents(allowedComparators?: Comparator[], allowedOperators?: Operator[]): StructuredQueryOutputParser;
 }
 export declare function formatAttributeInfo(info: AttributeInfo[]): string;
+/**
+ * A type that represents options for the query constructor chain.
+ */
 export type QueryConstructorChainOptions = {
     llm: BaseLanguageModel;
     documentContents: string;

package/dist/chains/query_constructor/index.js

@@ -17,6 +17,10 @@ const queryInputSchema = /* #__PURE__ */ z.object({
         .optional()
         .describe("logical condition statement for filtering documents"),
 });
+/**
+ * A class that extends AsymmetricStructuredOutputParser to parse
+ * structured query output.
+ */
 export class StructuredQueryOutputParser extends AsymmetricStructuredOutputParser {
     constructor(fields) {
         super({ ...fields, inputSchema: queryInputSchema });
@@ -35,6 +39,12 @@ export class StructuredQueryOutputParser extends AsymmetricStructuredOutputParse
         const { allowedComparators, allowedOperators } = fields;
         this.queryTransformer = new QueryTransformer(allowedComparators, allowedOperators);
     }
+    /**
+     * Processes the output of a structured query.
+     * @param query The query string.
+     * @param filter The filter condition.
+     * @returns A Promise that resolves to a StructuredQuery instance.
+     */
     async outputProcessor({ query, filter, }) {
         let myQuery = query;
         if (myQuery.length === 0) {
@@ -48,6 +58,13 @@ export class StructuredQueryOutputParser extends AsymmetricStructuredOutputParse
             return new StructuredQuery(query, parsedFilter);
         }
     }
+    /**
+     * Creates a new StructuredQueryOutputParser instance from the provided
+     * components.
+     * @param allowedComparators An array of allowed Comparator instances.
+     * @param allowedOperators An array of allowed Operator instances.
+     * @returns A new StructuredQueryOutputParser instance.
+     */
     static fromComponents(allowedComparators = [], allowedOperators = []) {
         return new StructuredQueryOutputParser({
             allowedComparators,

package/dist/chains/query_constructor/ir.cjs

@@ -14,9 +14,17 @@ exports.Comparators = {
     lte: "lte",
     gte: "gte",
 };
+/**
+ * Abstract class for visiting expressions. Subclasses must implement
+ * visitOperation, visitComparison, and visitStructuredQuery methods.
+ */
 class Visitor {
 }
 exports.Visitor = Visitor;
+/**
+ * Abstract class representing an expression. Subclasses must implement
+ * the exprName property and the accept method.
+ */
 class Expression {
     accept(visitor) {
         if (this.exprName === "Operation") {
@@ -34,9 +42,17 @@ class Expression {
     }
 }
 exports.Expression = Expression;
+/**
+ * Abstract class representing a filter directive. It extends the
+ * Expression class.
+ */
 class FilterDirective extends Expression {
 }
 exports.FilterDirective = FilterDirective;
+/**
+ * Class representing a comparison filter directive. It extends the
+ * FilterDirective class.
+ */
 class Comparison extends FilterDirective {
     constructor(comparator, attribute, value) {
         super();
@@ -67,6 +83,10 @@ class Comparison extends FilterDirective {
     }
 }
 exports.Comparison = Comparison;
+/**
+ * Class representing an operation filter directive. It extends the
+ * FilterDirective class.
+ */
 class Operation extends FilterDirective {
     constructor(operator, args) {
         super();
@@ -91,6 +111,10 @@ class Operation extends FilterDirective {
     }
 }
 exports.Operation = Operation;
+/**
+ * Class representing a structured query expression. It extends the
+ * Expression class.
+ */
 class StructuredQuery extends Expression {
     constructor(query, filter) {
         super();

package/dist/chains/query_constructor/ir.d.ts

@@ -1,14 +1,48 @@
 import { VectorStore } from "../../vectorstores/base.js";
+/**
+ * Represents logical AND operator.
+ */
 export type AND = "and";
+/**
+ * Represents logical OR operator.
+ */
 export type OR = "or";
+/**
+ * Represents logical NOT operator.
+ */
 export type NOT = "not";
+/**
+ * Represents a logical operator which can be AND, OR, or NOT.
+ */
 export type Operator = AND | OR | NOT;
+/**
+ * Represents equality comparison operator.
+ */
 export type EQ = "eq";
+/**
+ * Represents inequality comparison operator.
+ */
 export type NE = "ne";
+/**
+ * Represents less than comparison operator.
+ */
 export type LT = "lt";
+/**
+ * Represents greater than comparison operator.
+ */
 export type GT = "gt";
+/**
+ * Represents less than or equal to comparison operator.
+ */
 export type LTE = "lte";
+/**
+ * Represents greater than or equal to comparison operator.
+ */
 export type GTE = "gte";
+/**
+ * Represents a comparison operator which can be EQ, NE, LT, GT, LTE, or
+ * GTE.
+ */
 export type Comparator = EQ | NE | LT | GT | LTE | GTE;
 export declare const Operators: {
     [key: string]: Operator;
@@ -16,18 +50,35 @@ export declare const Operators: {
 export declare const Comparators: {
     [key: string]: Comparator;
 };
+/**
+ * Represents the result of visiting an operation or comparison
+ * expression.
+ */
 export type VisitorResult = VisitorOperationResult | VisitorComparisonResult;
+/**
+ * Represents the result of visiting an operation expression.
+ */
 export type VisitorOperationResult = {
     [operator: string]: VisitorResult[];
 };
+/**
+ * Represents the result of visiting a comparison expression.
+ */
 export type VisitorComparisonResult = {
     [attr: string]: {
         [comparator: string]: string | number;
     };
 };
+/**
+ * Represents the result of visiting a structured query expression.
+ */
 export type VisitorStructuredQueryResult = {
     filter?: VisitorComparisonResult | VisitorOperationResult;
 };
+/**
+ * Abstract class for visiting expressions. Subclasses must implement
+ * visitOperation, visitComparison, and visitStructuredQuery methods.
+ */
 export declare abstract class Visitor<T extends VectorStore = VectorStore> {
     VisitOperationOutput: object;
     VisitComparisonOutput: object;
@@ -40,12 +91,24 @@ export declare abstract class Visitor<T extends VectorStore = VectorStore> {
     abstract visitComparison(comparison: Comparison): this["VisitComparisonOutput"];
     abstract visitStructuredQuery(structuredQuery: StructuredQuery): this["VisitStructuredQueryOutput"];
 }
+/**
+ * Abstract class representing an expression. Subclasses must implement
+ * the exprName property and the accept method.
+ */
 export declare abstract class Expression {
     abstract exprName: "Operation" | "Comparison" | "StructuredQuery";
     accept(visitor: Visitor): object;
 }
+/**
+ * Abstract class representing a filter directive. It extends the
+ * Expression class.
+ */
 export declare abstract class FilterDirective extends Expression {
 }
+/**
+ * Class representing a comparison filter directive. It extends the
+ * FilterDirective class.
+ */
 export declare class Comparison extends FilterDirective {
     comparator: Comparator;
     attribute: string;
@@ -53,12 +116,20 @@ export declare class Comparison extends FilterDirective {
     exprName: "Comparison";
     constructor(comparator: Comparator, attribute: string, value: string | number);
 }
+/**
+ * Class representing an operation filter directive. It extends the
+ * FilterDirective class.
+ */
 export declare class Operation extends FilterDirective {
     operator: Operator;
     args?: FilterDirective[] | undefined;
     exprName: "Operation";
     constructor(operator: Operator, args?: FilterDirective[] | undefined);
 }
+/**
+ * Class representing a structured query expression. It extends the
+ * Expression class.
+ */
 export declare class StructuredQuery extends Expression {
     query: string;
     filter?: FilterDirective | undefined;

package/dist/chains/query_constructor/ir.js

@@ -11,8 +11,16 @@ export const Comparators = {
     lte: "lte",
     gte: "gte",
 };
+/**
+ * Abstract class for visiting expressions. Subclasses must implement
+ * visitOperation, visitComparison, and visitStructuredQuery methods.
+ */
 export class Visitor {
 }
+/**
+ * Abstract class representing an expression. Subclasses must implement
+ * the exprName property and the accept method.
+ */
 export class Expression {
     accept(visitor) {
         if (this.exprName === "Operation") {
@@ -29,8 +37,16 @@ export class Expression {
         }
     }
 }
+/**
+ * Abstract class representing a filter directive. It extends the
+ * Expression class.
+ */
 export class FilterDirective extends Expression {
 }
+/**
+ * Class representing a comparison filter directive. It extends the
+ * FilterDirective class.
+ */
 export class Comparison extends FilterDirective {
     constructor(comparator, attribute, value) {
         super();
@@ -60,6 +76,10 @@ export class Comparison extends FilterDirective {
         });
     }
 }
+/**
+ * Class representing an operation filter directive. It extends the
+ * FilterDirective class.
+ */
 export class Operation extends FilterDirective {
     constructor(operator, args) {
         super();
@@ -83,6 +103,10 @@ export class Operation extends FilterDirective {
         });
     }
 }
+/**
+ * Class representing a structured query expression. It extends the
+ * Expression class.
+ */
 export class StructuredQuery extends Expression {
     constructor(query, filter) {
         super();

package/dist/chains/query_constructor/parser.cjs

@@ -3,6 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueryTransformer = void 0;
 const ir_js_1 = require("./ir.cjs");
 const expression_js_1 = require("../../output_parsers/expression.cjs");
+/**
+ * A class for transforming and parsing query expressions.
+ */
 class QueryTransformer {
     constructor(allowedComparators = [], allowedOperators = []) {
         Object.defineProperty(this, "allowedComparators", {
@@ -18,6 +21,12 @@ class QueryTransformer {
             value: allowedOperators
         });
     }
+    /**
+     * Matches a function name to a comparator or operator. Throws an error if
+     * the function name is unknown or not allowed.
+     * @param funcName The function name to match.
+     * @returns The matched function name.
+     */
     matchFunctionName(funcName) {
         if (funcName in ir_js_1.Comparators) {
             if (this.allowedComparators.length > 0) {
@@ -47,6 +56,12 @@ class QueryTransformer {
         }
         throw new Error("Unknown function name");
     }
+    /**
+     * Transforms a parsed expression into an operation or comparison. Throws
+     * an error if the parsed expression is not supported.
+     * @param parsed The parsed expression to transform.
+     * @returns The transformed operation or comparison.
+     */
     transform(parsed) {
         const traverse = (node) => {
             switch (node.type) {
@@ -91,6 +106,12 @@ class QueryTransformer {
         };
         return traverse(parsed);
     }
+    /**
+     * Parses an expression and returns the transformed operation or
+     * comparison. Throws an error if the expression cannot be parsed.
+     * @param expression The expression to parse.
+     * @returns A Promise that resolves to the transformed operation or comparison.
+     */
     async parse(expression) {
         const expressionParser = new expression_js_1.ExpressionParser();
         const parsed = (await expressionParser.parse(expression));

package/dist/chains/query_constructor/parser.d.ts

@@ -1,12 +1,37 @@
 import { Comparator, Comparison, Operation, Operator } from "./ir.js";
+/**
+ * A type representing the possible types that can be traversed in an
+ * expression.
+ */
 export type TraverseType = boolean | Operation | Comparison | string | number | {
     [key: string]: TraverseType;
 } | TraverseType[];
+/**
+ * A class for transforming and parsing query expressions.
+ */
 export declare class QueryTransformer {
     allowedComparators: Comparator[];
     allowedOperators: Operator[];
     constructor(allowedComparators?: Comparator[], allowedOperators?: Operator[]);
+    /**
+     * Matches a function name to a comparator or operator. Throws an error if
+     * the function name is unknown or not allowed.
+     * @param funcName The function name to match.
+     * @returns The matched function name.
+     */
     private matchFunctionName;
+    /**
+     * Transforms a parsed expression into an operation or comparison. Throws
+     * an error if the parsed expression is not supported.
+     * @param parsed The parsed expression to transform.
+     * @returns The transformed operation or comparison.
+     */
     private transform;
+    /**
+     * Parses an expression and returns the transformed operation or
+     * comparison. Throws an error if the expression cannot be parsed.
+     * @param expression The expression to parse.
+     * @returns A Promise that resolves to the transformed operation or comparison.
+     */
     parse(expression: string): Promise<Operation | Comparison>;
 }

package/dist/chains/query_constructor/parser.js

@@ -1,5 +1,8 @@
 import { Comparators, Comparison, Operation, Operators, } from "./ir.js";
 import { ExpressionParser, } from "../../output_parsers/expression.js";
+/**
+ * A class for transforming and parsing query expressions.
+ */
 export class QueryTransformer {
     constructor(allowedComparators = [], allowedOperators = []) {
         Object.defineProperty(this, "allowedComparators", {
@@ -15,6 +18,12 @@ export class QueryTransformer {
             value: allowedOperators
         });
     }
+    /**
+     * Matches a function name to a comparator or operator. Throws an error if
+     * the function name is unknown or not allowed.
+     * @param funcName The function name to match.
+     * @returns The matched function name.
+     */
     matchFunctionName(funcName) {
         if (funcName in Comparators) {
             if (this.allowedComparators.length > 0) {
@@ -44,6 +53,12 @@ export class QueryTransformer {
         }
         throw new Error("Unknown function name");
     }
+    /**
+     * Transforms a parsed expression into an operation or comparison. Throws
+     * an error if the parsed expression is not supported.
+     * @param parsed The parsed expression to transform.
+     * @returns The transformed operation or comparison.
+     */
     transform(parsed) {
         const traverse = (node) => {
             switch (node.type) {
@@ -88,6 +103,12 @@ export class QueryTransformer {
         };
         return traverse(parsed);
     }
+    /**
+     * Parses an expression and returns the transformed operation or
+     * comparison. Throws an error if the expression cannot be parsed.
+     * @param expression The expression to parse.
+     * @returns A Promise that resolves to the transformed operation or comparison.
+     */
     async parse(expression) {
         const expressionParser = new ExpressionParser();
         const parsed = (await expressionParser.parse(expression));