@langchain/core 0.3.72 → 1.0.0-alpha.2

package/dist/structured_query/index.cjs

@@ -1,20 +1,55 @@
-"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("./base.cjs"), exports);
-__exportStar(require("./functional.cjs"), exports);
-__exportStar(require("./ir.cjs"), exports);
-__exportStar(require("./utils.cjs"), exports);
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_ir = require('./ir.cjs');
+const require_utils = require('./utils.cjs');
+const require_base = require('./base.cjs');
+const require_functional = require('./functional.cjs');
+
+//#region src/structured_query/index.ts
+var structured_query_exports = {};
+require_rolldown_runtime.__export(structured_query_exports, {
+	BaseTranslator: () => require_base.BaseTranslator,
+	BasicTranslator: () => require_base.BasicTranslator,
+	Comparators: () => require_ir.Comparators,
+	Comparison: () => require_ir.Comparison,
+	Expression: () => require_ir.Expression,
+	FilterDirective: () => require_ir.FilterDirective,
+	FunctionalTranslator: () => require_functional.FunctionalTranslator,
+	Operation: () => require_ir.Operation,
+	Operators: () => require_ir.Operators,
+	StructuredQuery: () => require_ir.StructuredQuery,
+	Visitor: () => require_ir.Visitor,
+	castValue: () => require_utils.castValue,
+	isBoolean: () => require_utils.isBoolean,
+	isFilterEmpty: () => require_utils.isFilterEmpty,
+	isFloat: () => require_utils.isFloat,
+	isInt: () => require_utils.isInt,
+	isObject: () => require_utils.isObject,
+	isString: () => require_utils.isString
+});
+
+//#endregion
+exports.BaseTranslator = require_base.BaseTranslator;
+exports.BasicTranslator = require_base.BasicTranslator;
+exports.Comparators = require_ir.Comparators;
+exports.Comparison = require_ir.Comparison;
+exports.Expression = require_ir.Expression;
+exports.FilterDirective = require_ir.FilterDirective;
+exports.FunctionalTranslator = require_functional.FunctionalTranslator;
+exports.Operation = require_ir.Operation;
+exports.Operators = require_ir.Operators;
+exports.StructuredQuery = require_ir.StructuredQuery;
+exports.Visitor = require_ir.Visitor;
+exports.castValue = require_utils.castValue;
+exports.isBoolean = require_utils.isBoolean;
+exports.isFilterEmpty = require_utils.isFilterEmpty;
+exports.isFloat = require_utils.isFloat;
+exports.isInt = require_utils.isInt;
+exports.isObject = require_utils.isObject;
+exports.isString = require_utils.isString;
+Object.defineProperty(exports, 'structured_query_exports', {
+  enumerable: true,
+  get: function () {
+    return structured_query_exports;
+  }
+});
+//# sourceMappingURL=index.cjs.map

package/dist/structured_query/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":[],"sources":["../../src/structured_query/index.ts"],"sourcesContent":["export * from \"./base.js\";\nexport * from \"./functional.js\";\nexport * from \"./ir.js\";\nexport * from \"./utils.js\";\n"],"mappings":""}

package/dist/structured_query/index.d.cts

@@ -0,0 +1,5 @@
+import { AND, Comparator, Comparators, Comparison, EQ, Expression, FilterDirective, GT, GTE, LT, LTE, NE, NOT, OR, Operation, Operator, Operators, StructuredQuery, Visitor, VisitorComparisonResult, VisitorOperationResult, VisitorResult, VisitorStructuredQueryResult } from "./ir.cjs";
+import { BaseTranslator, BasicTranslator, TranslatorOpts } from "./base.cjs";
+import { FunctionFilter, FunctionalTranslator } from "./functional.cjs";
+import { castValue, isBoolean, isFilterEmpty, isFloat, isInt, isObject, isString } from "./utils.cjs";
+export { AND, BaseTranslator, BasicTranslator, Comparator, Comparators, Comparison, EQ, Expression, FilterDirective, FunctionFilter, FunctionalTranslator, GT, GTE, LT, LTE, NE, NOT, OR, Operation, Operator, Operators, StructuredQuery, TranslatorOpts, Visitor, VisitorComparisonResult, VisitorOperationResult, VisitorResult, VisitorStructuredQueryResult, castValue, isBoolean, isFilterEmpty, isFloat, isInt, isObject, isString };

package/dist/structured_query/index.d.ts

@@ -1,4 +1,5 @@
-export * from "./base.js";
-export * from "./functional.js";
-export * from "./ir.js";
-export * from "./utils.js";
+import { AND, Comparator, Comparators, Comparison, EQ, Expression, FilterDirective, GT, GTE, LT, LTE, NE, NOT, OR, Operation, Operator, Operators, StructuredQuery, Visitor, VisitorComparisonResult, VisitorOperationResult, VisitorResult, VisitorStructuredQueryResult } from "./ir.js";
+import { BaseTranslator, BasicTranslator, TranslatorOpts } from "./base.js";
+import { FunctionFilter, FunctionalTranslator } from "./functional.js";
+import { castValue, isBoolean, isFilterEmpty, isFloat, isInt, isObject, isString } from "./utils.js";
+export { AND, BaseTranslator, BasicTranslator, Comparator, Comparators, Comparison, EQ, Expression, FilterDirective, FunctionFilter, FunctionalTranslator, GT, GTE, LT, LTE, NE, NOT, OR, Operation, Operator, Operators, StructuredQuery, TranslatorOpts, Visitor, VisitorComparisonResult, VisitorOperationResult, VisitorResult, VisitorStructuredQueryResult, castValue, isBoolean, isFilterEmpty, isFloat, isInt, isObject, isString };

package/dist/structured_query/index.js

@@ -1,4 +1,32 @@
-export * from "./base.js";
-export * from "./functional.js";
-export * from "./ir.js";
-export * from "./utils.js";
+import { __export } from "../_virtual/rolldown_runtime.js";
+import { Comparators, Comparison, Expression, FilterDirective, Operation, Operators, StructuredQuery, Visitor } from "./ir.js";
+import { castValue, isBoolean, isFilterEmpty, isFloat, isInt, isObject, isString } from "./utils.js";
+import { BaseTranslator, BasicTranslator } from "./base.js";
+import { FunctionalTranslator } from "./functional.js";
+
+//#region src/structured_query/index.ts
+var structured_query_exports = {};
+__export(structured_query_exports, {
+	BaseTranslator: () => BaseTranslator,
+	BasicTranslator: () => BasicTranslator,
+	Comparators: () => Comparators,
+	Comparison: () => Comparison,
+	Expression: () => Expression,
+	FilterDirective: () => FilterDirective,
+	FunctionalTranslator: () => FunctionalTranslator,
+	Operation: () => Operation,
+	Operators: () => Operators,
+	StructuredQuery: () => StructuredQuery,
+	Visitor: () => Visitor,
+	castValue: () => castValue,
+	isBoolean: () => isBoolean,
+	isFilterEmpty: () => isFilterEmpty,
+	isFloat: () => isFloat,
+	isInt: () => isInt,
+	isObject: () => isObject,
+	isString: () => isString
+});
+
+//#endregion
+export { BaseTranslator, BasicTranslator, Comparators, Comparison, Expression, FilterDirective, FunctionalTranslator, Operation, Operators, StructuredQuery, Visitor, castValue, isBoolean, isFilterEmpty, isFloat, isInt, isObject, isString, structured_query_exports };
+//# sourceMappingURL=index.js.map

package/dist/structured_query/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../src/structured_query/index.ts"],"sourcesContent":["export * from \"./base.js\";\nexport * from \"./functional.js\";\nexport * from \"./ir.js\";\nexport * from \"./utils.js\";\n"],"mappings":""}

package/dist/structured_query/ir.cjs

@@ -1,141 +1,85 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StructuredQuery = exports.Operation = exports.Comparison = exports.FilterDirective = exports.Expression = exports.Visitor = exports.Comparators = exports.Operators = void 0;
-exports.Operators = {
-    and: "and",
-    or: "or",
-    not: "not",
+
+//#region src/structured_query/ir.ts
+const Operators = {
+	and: "and",
+	or: "or",
+	not: "not"
 };
-exports.Comparators = {
-    eq: "eq",
-    ne: "ne",
-    lt: "lt",
-    gt: "gt",
-    lte: "lte",
-    gte: "gte",
+const Comparators = {
+	eq: "eq",
+	ne: "ne",
+	lt: "lt",
+	gt: "gt",
+	lte: "lte",
+	gte: "gte"
 };
 /**
- * Abstract class for visiting expressions. Subclasses must implement
- * visitOperation, visitComparison, and visitStructuredQuery methods.
- */
-class Visitor {
-}
-exports.Visitor = Visitor;
+* Abstract class for visiting expressions. Subclasses must implement
+* visitOperation, visitComparison, and visitStructuredQuery methods.
+*/
+var Visitor = class {};
 /**
- * Abstract class representing an expression. Subclasses must implement
- * the exprName property and the accept method.
- */
-class Expression {
-    accept(visitor) {
-        if (this.exprName === "Operation") {
-            return visitor.visitOperation(this);
-        }
-        else if (this.exprName === "Comparison") {
-            return visitor.visitComparison(this);
-        }
-        else if (this.exprName === "StructuredQuery") {
-            return visitor.visitStructuredQuery(this);
-        }
-        else {
-            throw new Error("Unknown Expression type");
-        }
-    }
-}
-exports.Expression = Expression;
+* Abstract class representing an expression. Subclasses must implement
+* the exprName property and the accept method.
+*/
+var Expression = class {
+	accept(visitor) {
+		if (this.exprName === "Operation") return visitor.visitOperation(this);
+		else if (this.exprName === "Comparison") return visitor.visitComparison(this);
+		else if (this.exprName === "StructuredQuery") return visitor.visitStructuredQuery(this);
+		else throw new Error("Unknown Expression type");
+	}
+};
 /**
- * Abstract class representing a filter directive. It extends the
- * Expression class.
- */
-class FilterDirective extends Expression {
-}
-exports.FilterDirective = FilterDirective;
+* Abstract class representing a filter directive. It extends the
+* Expression class.
+*/
+var FilterDirective = class extends Expression {};
 /**
- * Class representing a comparison filter directive. It extends the
- * FilterDirective class.
- */
-class Comparison extends FilterDirective {
-    constructor(comparator, attribute, value) {
-        super();
-        Object.defineProperty(this, "comparator", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: comparator
-        });
-        Object.defineProperty(this, "attribute", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: attribute
-        });
-        Object.defineProperty(this, "value", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: value
-        });
-        Object.defineProperty(this, "exprName", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: "Comparison"
-        });
-    }
-}
-exports.Comparison = Comparison;
+* Class representing a comparison filter directive. It extends the
+* FilterDirective class.
+*/
+var Comparison = class extends FilterDirective {
+	exprName = "Comparison";
+	constructor(comparator, attribute, value) {
+		super();
+		this.comparator = comparator;
+		this.attribute = attribute;
+		this.value = value;
+	}
+};
 /**
- * Class representing an operation filter directive. It extends the
- * FilterDirective class.
- */
-class Operation extends FilterDirective {
-    constructor(operator, args) {
-        super();
-        Object.defineProperty(this, "operator", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: operator
-        });
-        Object.defineProperty(this, "args", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: args
-        });
-        Object.defineProperty(this, "exprName", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: "Operation"
-        });
-    }
-}
-exports.Operation = Operation;
+* Class representing an operation filter directive. It extends the
+* FilterDirective class.
+*/
+var Operation = class extends FilterDirective {
+	exprName = "Operation";
+	constructor(operator, args) {
+		super();
+		this.operator = operator;
+		this.args = args;
+	}
+};
 /**
- * Class representing a structured query expression. It extends the
- * Expression class.
- */
-class StructuredQuery extends Expression {
-    constructor(query, filter) {
-        super();
-        Object.defineProperty(this, "query", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: query
-        });
-        Object.defineProperty(this, "filter", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: filter
-        });
-        Object.defineProperty(this, "exprName", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: "StructuredQuery"
-        });
-    }
-}
+* Class representing a structured query expression. It extends the
+* Expression class.
+*/
+var StructuredQuery = class extends Expression {
+	exprName = "StructuredQuery";
+	constructor(query, filter) {
+		super();
+		this.query = query;
+		this.filter = filter;
+	}
+};
+
+//#endregion
+exports.Comparators = Comparators;
+exports.Comparison = Comparison;
+exports.Expression = Expression;
+exports.FilterDirective = FilterDirective;
+exports.Operation = Operation;
+exports.Operators = Operators;
 exports.StructuredQuery = StructuredQuery;
+exports.Visitor = Visitor;
+//# sourceMappingURL=ir.cjs.map

package/dist/structured_query/ir.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ir.cjs","names":["Operators: { [key: string]: Operator }","Comparators: { [key: string]: Comparator }","visitor: Visitor","comparator: Comparator","attribute: string","value: ValueTypes","operator: Operator","args?: FilterDirective[]","query: string","filter?: FilterDirective"],"sources":["../../src/structured_query/ir.ts"],"sourcesContent":["import { VectorStore } from \"../vectorstores.js\";\n\n/**\n * Represents logical AND operator.\n */\nexport type AND = \"and\";\n/**\n * Represents logical OR operator.\n */\nexport type OR = \"or\";\n/**\n * Represents logical NOT operator.\n */\nexport type NOT = \"not\";\n\n/**\n * Represents a logical operator which can be AND, OR, or NOT.\n */\nexport type Operator = AND | OR | NOT;\n\n/**\n * Represents equality comparison operator.\n */\nexport type EQ = \"eq\";\n/**\n * Represents inequality comparison operator.\n */\nexport type NE = \"ne\";\n/**\n * Represents less than comparison operator.\n */\nexport type LT = \"lt\";\n/**\n * Represents greater than comparison operator.\n */\nexport type GT = \"gt\";\n/**\n * Represents less than or equal to comparison operator.\n */\nexport type LTE = \"lte\";\n/**\n * Represents greater than or equal to comparison operator.\n */\nexport type GTE = \"gte\";\n\n/**\n * Represents a comparison operator which can be EQ, NE, LT, GT, LTE, or\n * GTE.\n */\nexport type Comparator = EQ | NE | LT | GT | LTE | GTE;\n\nexport const Operators: { [key: string]: Operator } = {\n  and: \"and\",\n  or: \"or\",\n  not: \"not\",\n};\n\nexport const Comparators: { [key: string]: Comparator } = {\n  eq: \"eq\",\n  ne: \"ne\",\n  lt: \"lt\",\n  gt: \"gt\",\n  lte: \"lte\",\n  gte: \"gte\",\n};\n\n/**\n * Represents the result of visiting an operation or comparison\n * expression.\n */\nexport type VisitorResult = VisitorOperationResult | VisitorComparisonResult;\n\n/**\n * Represents the result of visiting an operation expression.\n */\nexport type VisitorOperationResult = {\n  [operator: string]: VisitorResult[];\n};\n\n/**\n * Represents the result of visiting a comparison expression.\n */\nexport type VisitorComparisonResult = {\n  [attr: string]: {\n    [comparator: string]: string | number | boolean;\n  };\n};\n\n/**\n * Represents the result of visiting a structured query expression.\n */\nexport type VisitorStructuredQueryResult = {\n  filter?: VisitorComparisonResult | VisitorOperationResult;\n};\n\n/**\n * Abstract class for visiting expressions. Subclasses must implement\n * visitOperation, visitComparison, and visitStructuredQuery methods.\n */\nexport abstract class Visitor<T extends VectorStore = VectorStore> {\n  declare VisitOperationOutput: object;\n\n  declare VisitComparisonOutput: object;\n\n  declare VisitStructuredQueryOutput: { filter?: T[\"FilterType\"] };\n\n  abstract allowedOperators: Operator[];\n\n  abstract allowedComparators: Comparator[];\n\n  abstract visitOperation(operation: Operation): this[\"VisitOperationOutput\"];\n\n  abstract visitComparison(\n    comparison: Comparison\n  ): this[\"VisitComparisonOutput\"];\n\n  abstract visitStructuredQuery(\n    structuredQuery: StructuredQuery\n  ): this[\"VisitStructuredQueryOutput\"];\n}\n\n/**\n * Abstract class representing an expression. Subclasses must implement\n * the exprName property and the accept method.\n */\nexport abstract class Expression {\n  abstract exprName: \"Operation\" | \"Comparison\" | \"StructuredQuery\";\n\n  accept(visitor: Visitor) {\n    if (this.exprName === \"Operation\") {\n      return visitor.visitOperation(this as unknown as Operation);\n    } else if (this.exprName === \"Comparison\") {\n      return visitor.visitComparison(this as unknown as Comparison);\n    } else if (this.exprName === \"StructuredQuery\") {\n      return visitor.visitStructuredQuery(this as unknown as StructuredQuery);\n    } else {\n      throw new Error(\"Unknown Expression type\");\n    }\n  }\n}\n\n/**\n * Abstract class representing a filter directive. It extends the\n * Expression class.\n */\nexport abstract class FilterDirective extends Expression {}\n\n/**\n * Class representing a comparison filter directive. It extends the\n * FilterDirective class.\n */\nexport class Comparison<ValueTypes = string | number> extends FilterDirective {\n  exprName = \"Comparison\" as const;\n\n  constructor(\n    public comparator: Comparator,\n    public attribute: string,\n    public value: ValueTypes\n  ) {\n    super();\n  }\n}\n\n/**\n * Class representing an operation filter directive. It extends the\n * FilterDirective class.\n */\nexport class Operation extends FilterDirective {\n  exprName = \"Operation\" as const;\n\n  constructor(public operator: Operator, public args?: FilterDirective[]) {\n    super();\n  }\n}\n\n/**\n * Class representing a structured query expression. It extends the\n * Expression class.\n */\nexport class StructuredQuery extends Expression {\n  exprName = \"StructuredQuery\" as const;\n\n  constructor(public query: string, public filter?: FilterDirective) {\n    super();\n  }\n}\n"],"mappings":";;AAmDA,MAAaA,YAAyC;CACpD,KAAK;CACL,IAAI;CACJ,KAAK;AACN;AAED,MAAaC,cAA6C;CACxD,IAAI;CACJ,IAAI;CACJ,IAAI;CACJ,IAAI;CACJ,KAAK;CACL,KAAK;AACN;;;;;AAmCD,IAAsB,UAAtB,MAAmE,CAoBlE;;;;;AAMD,IAAsB,aAAtB,MAAiC;CAG/B,OAAOC,SAAkB;AACvB,MAAI,KAAK,aAAa,YACpB,QAAO,QAAQ,eAAe,KAA6B;WAClD,KAAK,aAAa,aAC3B,QAAO,QAAQ,gBAAgB,KAA8B;WACpD,KAAK,aAAa,kBAC3B,QAAO,QAAQ,qBAAqB,KAAmC;MAEvE,OAAM,IAAI,MAAM;CAEnB;AACF;;;;;AAMD,IAAsB,kBAAtB,cAA8C,WAAW,CAAE;;;;;AAM3D,IAAa,aAAb,cAA8D,gBAAgB;CAC5E,WAAW;CAEX,YACSC,YACAC,WACAC,OACP;EACA,OAAO;EAJA;EACA;EACA;CAGR;AACF;;;;;AAMD,IAAa,YAAb,cAA+B,gBAAgB;CAC7C,WAAW;CAEX,YAAmBC,UAA2BC,MAA0B;EACtE,OAAO;EADU;EAA2B;CAE7C;AACF;;;;;AAMD,IAAa,kBAAb,cAAqC,WAAW;CAC9C,WAAW;CAEX,YAAmBC,OAAsBC,QAA0B;EACjE,OAAO;EADU;EAAsB;CAExC;AACF"}

package/dist/structured_query/ir.d.cts

@@ -0,0 +1,143 @@
+import { VectorStore } from "../vectorstores.cjs";
+
+//#region src/structured_query/ir.d.ts
+
+/**
+ * Represents logical AND operator.
+ */
+type AND = "and";
+/**
+ * Represents logical OR operator.
+ */
+type OR = "or";
+/**
+ * Represents logical NOT operator.
+ */
+type NOT = "not";
+/**
+ * Represents a logical operator which can be AND, OR, or NOT.
+ */
+type Operator = AND | OR | NOT;
+/**
+ * Represents equality comparison operator.
+ */
+type EQ = "eq";
+/**
+ * Represents inequality comparison operator.
+ */
+type NE = "ne";
+/**
+ * Represents less than comparison operator.
+ */
+type LT = "lt";
+/**
+ * Represents greater than comparison operator.
+ */
+type GT = "gt";
+/**
+ * Represents less than or equal to comparison operator.
+ */
+type LTE = "lte";
+/**
+ * Represents greater than or equal to comparison operator.
+ */
+type GTE = "gte";
+/**
+ * Represents a comparison operator which can be EQ, NE, LT, GT, LTE, or
+ * GTE.
+ */
+type Comparator = EQ | NE | LT | GT | LTE | GTE;
+declare const Operators: {
+  [key: string]: Operator;
+};
+declare const Comparators: {
+  [key: string]: Comparator;
+};
+/**
+ * Represents the result of visiting an operation or comparison
+ * expression.
+ */
+type VisitorResult = VisitorOperationResult | VisitorComparisonResult;
+/**
+ * Represents the result of visiting an operation expression.
+ */
+type VisitorOperationResult = {
+  [operator: string]: VisitorResult[];
+};
+/**
+ * Represents the result of visiting a comparison expression.
+ */
+type VisitorComparisonResult = {
+  [attr: string]: {
+    [comparator: string]: string | number | boolean;
+  };
+};
+/**
+ * Represents the result of visiting a structured query expression.
+ */
+type VisitorStructuredQueryResult = {
+  filter?: VisitorComparisonResult | VisitorOperationResult;
+};
+/**
+ * Abstract class for visiting expressions. Subclasses must implement
+ * visitOperation, visitComparison, and visitStructuredQuery methods.
+ */
+declare abstract class Visitor<T extends VectorStore = VectorStore> {
+  VisitOperationOutput: object;
+  VisitComparisonOutput: object;
+  VisitStructuredQueryOutput: {
+    filter?: T["FilterType"];
+  };
+  abstract allowedOperators: Operator[];
+  abstract allowedComparators: Comparator[];
+  abstract visitOperation(operation: Operation): this["VisitOperationOutput"];
+  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.
+ */
+declare abstract class Expression {
+  abstract exprName: "Operation" | "Comparison" | "StructuredQuery";
+  accept(visitor: Visitor): object;
+}
+/**
+ * Abstract class representing a filter directive. It extends the
+ * Expression class.
+ */
+declare abstract class FilterDirective extends Expression {}
+/**
+ * Class representing a comparison filter directive. It extends the
+ * FilterDirective class.
+ */
+declare class Comparison<ValueTypes = string | number> extends FilterDirective {
+  comparator: Comparator;
+  attribute: string;
+  value: ValueTypes;
+  exprName: "Comparison";
+  constructor(comparator: Comparator, attribute: string, value: ValueTypes);
+}
+/**
+ * Class representing an operation filter directive. It extends the
+ * FilterDirective class.
+ */
+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.
+ */
+declare class StructuredQuery extends Expression {
+  query: string;
+  filter?: FilterDirective | undefined;
+  exprName: "StructuredQuery";
+  constructor(query: string, filter?: FilterDirective | undefined);
+}
+//#endregion
+export { AND, Comparator, Comparators, Comparison, EQ, Expression, FilterDirective, GT, GTE, LT, LTE, NE, NOT, OR, Operation, Operator, Operators, StructuredQuery, Visitor, VisitorComparisonResult, VisitorOperationResult, VisitorResult, VisitorStructuredQueryResult };
+//# sourceMappingURL=ir.d.cts.map

package/dist/structured_query/ir.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ir.d.cts","names":["VectorStore","AND","OR","NOT","Operator","EQ","NE","LT","GT","LTE","GTE","Comparator","Operators","Comparators","VisitorResult","VisitorOperationResult","VisitorComparisonResult","VisitorStructuredQueryResult","Visitor","T","Operation","Comparison","StructuredQuery","Expression","FilterDirective","ValueTypes"],"sources":["../../src/structured_query/ir.d.ts"],"sourcesContent":["import { VectorStore } from \"../vectorstores.js\";\n/**\n * Represents logical AND operator.\n */\nexport type AND = \"and\";\n/**\n * Represents logical OR operator.\n */\nexport type OR = \"or\";\n/**\n * Represents logical NOT operator.\n */\nexport type NOT = \"not\";\n/**\n * Represents a logical operator which can be AND, OR, or NOT.\n */\nexport type Operator = AND | OR | NOT;\n/**\n * Represents equality comparison operator.\n */\nexport type EQ = \"eq\";\n/**\n * Represents inequality comparison operator.\n */\nexport type NE = \"ne\";\n/**\n * Represents less than comparison operator.\n */\nexport type LT = \"lt\";\n/**\n * Represents greater than comparison operator.\n */\nexport type GT = \"gt\";\n/**\n * Represents less than or equal to comparison operator.\n */\nexport type LTE = \"lte\";\n/**\n * Represents greater than or equal to comparison operator.\n */\nexport type GTE = \"gte\";\n/**\n * Represents a comparison operator which can be EQ, NE, LT, GT, LTE, or\n * GTE.\n */\nexport type Comparator = EQ | NE | LT | GT | LTE | GTE;\nexport declare const Operators: {\n    [key: string]: Operator;\n};\nexport declare const Comparators: {\n    [key: string]: Comparator;\n};\n/**\n * Represents the result of visiting an operation or comparison\n * expression.\n */\nexport type VisitorResult = VisitorOperationResult | VisitorComparisonResult;\n/**\n * Represents the result of visiting an operation expression.\n */\nexport type VisitorOperationResult = {\n    [operator: string]: VisitorResult[];\n};\n/**\n * Represents the result of visiting a comparison expression.\n */\nexport type VisitorComparisonResult = {\n    [attr: string]: {\n        [comparator: string]: string | number | boolean;\n    };\n};\n/**\n * Represents the result of visiting a structured query expression.\n */\nexport type VisitorStructuredQueryResult = {\n    filter?: VisitorComparisonResult | VisitorOperationResult;\n};\n/**\n * Abstract class for visiting expressions. Subclasses must implement\n * visitOperation, visitComparison, and visitStructuredQuery methods.\n */\nexport declare abstract class Visitor<T extends VectorStore = VectorStore> {\n    VisitOperationOutput: object;\n    VisitComparisonOutput: object;\n    VisitStructuredQueryOutput: {\n        filter?: T[\"FilterType\"];\n    };\n    abstract allowedOperators: Operator[];\n    abstract allowedComparators: Comparator[];\n    abstract visitOperation(operation: Operation): this[\"VisitOperationOutput\"];\n    abstract visitComparison(comparison: Comparison): this[\"VisitComparisonOutput\"];\n    abstract visitStructuredQuery(structuredQuery: StructuredQuery): this[\"VisitStructuredQueryOutput\"];\n}\n/**\n * Abstract class representing an expression. Subclasses must implement\n * the exprName property and the accept method.\n */\nexport declare abstract class Expression {\n    abstract exprName: \"Operation\" | \"Comparison\" | \"StructuredQuery\";\n    accept(visitor: Visitor): object;\n}\n/**\n * Abstract class representing a filter directive. It extends the\n * Expression class.\n */\nexport declare abstract class FilterDirective extends Expression {\n}\n/**\n * Class representing a comparison filter directive. It extends the\n * FilterDirective class.\n */\nexport declare class Comparison<ValueTypes = string | number> extends FilterDirective {\n    comparator: Comparator;\n    attribute: string;\n    value: ValueTypes;\n    exprName: \"Comparison\";\n    constructor(comparator: Comparator, attribute: string, value: ValueTypes);\n}\n/**\n * Class representing an operation filter directive. It extends the\n * FilterDirective class.\n */\nexport declare class Operation extends FilterDirective {\n    operator: Operator;\n    args?: FilterDirective[] | undefined;\n    exprName: \"Operation\";\n    constructor(operator: Operator, args?: FilterDirective[] | undefined);\n}\n/**\n * Class representing a structured query expression. It extends the\n * Expression class.\n */\nexport declare class StructuredQuery extends Expression {\n    query: string;\n    filter?: FilterDirective | undefined;\n    exprName: \"StructuredQuery\";\n    constructor(query: string, filter?: FilterDirective | undefined);\n}\n"],"mappings":";;;;;;AAIA;AAIYE,KAJAD,GAAAA,GAIE,KAAA;AAId;AAIA;;AAAuBA,KARXC,EAAAA,GAQWD,IAAAA;;;AAAc;AAIzBI,KARAF,GAAAA,GAQE,KAAA;AAId;AAIA;AAIA;AAIYM,KApBAL,QAAAA,GAAWH,GAoBR,GApBcC,EAoBd,GApBmBC,GAoBnB;AAIf;AAKA;;AAAyBE,KAzBbA,EAAAA,GAyBaA,IAAAA;;;;AAAoBI,KArBjCH,EAAAA,GAqBiCG,IAAAA;;AAAS;AACtD;AAGqBI,KArBTN,EAAAA,GAqBSM,IAEpB;AAKD;;;AAAqDG,KAxBzCR,EAAAA,GAwByCQ,IAAAA;AAAuB;AAI5E;AAMA;AAQYC,KAtCAR,GAAAA,GAsCAQ,KAAAA;;;;AACiD,KAnCjDP,GAAAA,GAmCiD,KAAA;AAM7D;;;;AAIiBS,KAxCLR,UAAAA,GAAaN,EAwCRc,GAxCab,EAwCba,GAxCkBZ,EAwClBY,GAxCuBX,EAwCvBW,GAxC4BV,GAwC5BU,GAxCkCT,GAwClCS;AAEcf,cAzCVQ,SAyCUR,EAAAA;EAAQ,CAAA,GACNO,EAAAA,MAAAA,CAAAA,EAzCdP,QAyCcO;CAAU;AAEFU,cAzCpBR,WAyCoBQ,EAAAA;EAAU,CAAA,GACAC,EAAAA,MAAAA,CAAAA,EAzChCX,UAyCgCW;AAAe,CAAA;AAMlE;AAQA;AAMA;;AACgBX,KAxDJG,aAAAA,GAAgBC,sBAwDZJ,GAxDqCK,uBAwDrCL;;;;AADsDa,KAnD1DT,sBAAAA,GAmD0DS;EAAe,CAAA,QAAA,EAAA,MAAA,CAAA,EAlD7DV,aAkD6D,EAAA;AAWrF,CAAA;;;;AAI0BV,KA5DdY,uBAAAA,GA4DcZ;EAAQ,CAAA,IAASoB,EAAAA,MAAAA,CAAAA,EAAAA;IAJJA,CAAAA,UAAAA,EAAAA,MAAAA,CAAAA,EAAAA,MAAAA,GAAAA,MAAAA,GAAAA,OAAAA;EAAe,CAAA;AAUtD,CAAA;;;;AAA6CD,KA1DjCN,4BAAAA,GA0DiCM;EAAU,MAAA,CAAA,EAzD1CP,uBAyD0C,GAzDhBD,sBAyDgB;;;;;;uBAnDzBG,kBAAkBlB,cAAcA;;;;aAI7CmB;;6BAEcf;+BACEO;qCACMS;uCACEC;iDACUC;;;;;;uBAMrBC,UAAAA;;kBAEVL;;;;;;uBAMUM,eAAAA,SAAwBD,UAAU;;;;;cAM3CF,iDAAiDG,eAAAA;cACtDb;;SAELc;;0BAEiBd,sCAAsCc;;;;;;cAM7CL,SAAAA,SAAkBI,eAAAA;YACzBpB;SACHoB;;wBAEepB,iBAAiBoB;;;;;;cAMtBF,eAAAA,SAAwBC,UAAAA;;WAEhCC;;sCAE2BA"}