@langchain/core 0.3.72 → 1.0.0-alpha.2

package/dist/structured_query/ir.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"ir.d.ts","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"}

package/dist/structured_query/ir.js

@@ -1,132 +1,77 @@
-export const Operators = {
-    and: "and",
-    or: "or",
-    not: "not",
+//#region src/structured_query/ir.ts
+const Operators = {
+	and: "and",
+	or: "or",
+	not: "not"
 };
-export const 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.
- */
-export class 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.
- */
-export 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");
-        }
-    }
-}
+* 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.
- */
-export class FilterDirective extends Expression {
-}
+* 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.
- */
-export 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"
-        });
-    }
-}
+* 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.
- */
-export 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"
-        });
-    }
-}
+* 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.
- */
-export 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
+export { Comparators, Comparison, Expression, FilterDirective, Operation, Operators, StructuredQuery, Visitor };
+//# sourceMappingURL=ir.js.map

package/dist/structured_query/ir.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ir.js","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/utils.cjs

@@ -1,103 +1,78 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isObject = isObject;
-exports.isFilterEmpty = isFilterEmpty;
-exports.isInt = isInt;
-exports.isFloat = isFloat;
-exports.isString = isString;
-exports.isBoolean = isBoolean;
-exports.castValue = castValue;
+
+//#region src/structured_query/utils.ts
 /**
- * Checks if the provided argument is an object and not an array.
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
+* Checks if the provided argument is an object and not an array.
+*/
 function isObject(obj) {
-    return obj && typeof obj === "object" && !Array.isArray(obj);
+	return obj && typeof obj === "object" && !Array.isArray(obj);
 }
 /**
- * Checks if a provided filter is empty. The filter can be a function, an
- * object, a string, or undefined.
- */
-function isFilterEmpty(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-filter) {
-    if (!filter)
-        return true;
-    // for Milvus
-    if (typeof filter === "string" && filter.length > 0) {
-        return false;
-    }
-    if (typeof filter === "function") {
-        return false;
-    }
-    return isObject(filter) && Object.keys(filter).length === 0;
+* Checks if a provided filter is empty. The filter can be a function, an
+* object, a string, or undefined.
+*/
+function isFilterEmpty(filter) {
+	if (!filter) return true;
+	if (typeof filter === "string" && filter.length > 0) return false;
+	if (typeof filter === "function") return false;
+	return isObject(filter) && Object.keys(filter).length === 0;
 }
 /**
- * Checks if the provided value is an integer.
- */
+* Checks if the provided value is an integer.
+*/
 function isInt(value) {
-    if (typeof value === "number") {
-        return value % 1 === 0;
-    }
-    else if (typeof value === "string") {
-        const numberValue = parseInt(value, 10);
-        return (!Number.isNaN(numberValue) &&
-            numberValue % 1 === 0 &&
-            numberValue.toString() === value);
-    }
-    return false;
+	if (typeof value === "number") return value % 1 === 0;
+	else if (typeof value === "string") {
+		const numberValue = parseInt(value, 10);
+		return !Number.isNaN(numberValue) && numberValue % 1 === 0 && numberValue.toString() === value;
+	}
+	return false;
 }
 /**
- * Checks if the provided value is a floating-point number.
- */
+* Checks if the provided value is a floating-point number.
+*/
 function isFloat(value) {
-    if (typeof value === "number") {
-        return value % 1 !== 0;
-    }
-    else if (typeof value === "string") {
-        const numberValue = parseFloat(value);
-        return (!Number.isNaN(numberValue) &&
-            numberValue % 1 !== 0 &&
-            numberValue.toString() === value);
-    }
-    return false;
+	if (typeof value === "number") return value % 1 !== 0;
+	else if (typeof value === "string") {
+		const numberValue = parseFloat(value);
+		return !Number.isNaN(numberValue) && numberValue % 1 !== 0 && numberValue.toString() === value;
+	}
+	return false;
 }
 /**
- * Checks if the provided value is a string that cannot be parsed into a
- * number.
- */
+* Checks if the provided value is a string that cannot be parsed into a
+* number.
+*/
 function isString(value) {
-    return (typeof value === "string" &&
-        (Number.isNaN(parseFloat(value)) || parseFloat(value).toString() !== value));
+	return typeof value === "string" && (Number.isNaN(parseFloat(value)) || parseFloat(value).toString() !== value);
 }
 /**
- * Checks if the provided value is a boolean.
- */
+* Checks if the provided value is a boolean.
+*/
 function isBoolean(value) {
-    return typeof value === "boolean";
+	return typeof value === "boolean";
 }
 /**
- * Casts a value that might be string or number to actual string or number.
- * Since LLM might return back an integer/float as a string, we need to cast
- * it back to a number, as many vector databases can't handle number as string
- * values as a comparator.
- */
+* Casts a value that might be string or number to actual string or number.
+* Since LLM might return back an integer/float as a string, we need to cast
+* it back to a number, as many vector databases can't handle number as string
+* values as a comparator.
+*/
 function castValue(input) {
-    let value;
-    if (isString(input)) {
-        value = input;
-    }
-    else if (isInt(input)) {
-        value = parseInt(input, 10);
-    }
-    else if (isFloat(input)) {
-        value = parseFloat(input);
-    }
-    else if (isBoolean(input)) {
-        value = Boolean(input);
-    }
-    else {
-        throw new Error("Unsupported value type");
-    }
-    return value;
+	let value;
+	if (isString(input)) value = input;
+	else if (isInt(input)) value = parseInt(input, 10);
+	else if (isFloat(input)) value = parseFloat(input);
+	else if (isBoolean(input)) value = Boolean(input);
+	else throw new Error("Unsupported value type");
+	return value;
 }
+
+//#endregion
+exports.castValue = castValue;
+exports.isBoolean = isBoolean;
+exports.isFilterEmpty = isFilterEmpty;
+exports.isFloat = isFloat;
+exports.isInt = isInt;
+exports.isObject = isObject;
+exports.isString = isString;
+//# sourceMappingURL=utils.cjs.map

package/dist/structured_query/utils.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.cjs","names":["obj: any","filter: ((q: any) => any) | object | string | undefined","value: unknown","input: unknown"],"sources":["../../src/structured_query/utils.ts"],"sourcesContent":["/**\n * Checks if the provided argument is an object and not an array.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function isObject(obj: any): obj is object {\n  return obj && typeof obj === \"object\" && !Array.isArray(obj);\n}\n\n/**\n * Checks if a provided filter is empty. The filter can be a function, an\n * object, a string, or undefined.\n */\nexport function isFilterEmpty(\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  filter: ((q: any) => any) | object | string | undefined\n): filter is undefined {\n  if (!filter) return true;\n  // for Milvus\n  if (typeof filter === \"string\" && filter.length > 0) {\n    return false;\n  }\n  if (typeof filter === \"function\") {\n    return false;\n  }\n  return isObject(filter) && Object.keys(filter).length === 0;\n}\n\n/**\n * Checks if the provided value is an integer.\n */\nexport function isInt(value: unknown): boolean {\n  if (typeof value === \"number\") {\n    return value % 1 === 0;\n  } else if (typeof value === \"string\") {\n    const numberValue = parseInt(value, 10);\n    return (\n      !Number.isNaN(numberValue) &&\n      numberValue % 1 === 0 &&\n      numberValue.toString() === value\n    );\n  }\n\n  return false;\n}\n\n/**\n * Checks if the provided value is a floating-point number.\n */\nexport function isFloat(value: unknown): boolean {\n  if (typeof value === \"number\") {\n    return value % 1 !== 0;\n  } else if (typeof value === \"string\") {\n    const numberValue = parseFloat(value);\n    return (\n      !Number.isNaN(numberValue) &&\n      numberValue % 1 !== 0 &&\n      numberValue.toString() === value\n    );\n  }\n\n  return false;\n}\n\n/**\n * Checks if the provided value is a string that cannot be parsed into a\n * number.\n */\nexport function isString(value: unknown): boolean {\n  return (\n    typeof value === \"string\" &&\n    (Number.isNaN(parseFloat(value)) || parseFloat(value).toString() !== value)\n  );\n}\n\n/**\n * Checks if the provided value is a boolean.\n */\nexport function isBoolean(value: unknown): boolean {\n  return typeof value === \"boolean\";\n}\n\n/**\n * Casts a value that might be string or number to actual string or number.\n * Since LLM might return back an integer/float as a string, we need to cast\n * it back to a number, as many vector databases can't handle number as string\n * values as a comparator.\n */\nexport function castValue(input: unknown): string | number | boolean {\n  let value;\n  if (isString(input)) {\n    value = input as string;\n  } else if (isInt(input)) {\n    value = parseInt(input as string, 10);\n  } else if (isFloat(input)) {\n    value = parseFloat(input as string);\n  } else if (isBoolean(input)) {\n    value = Boolean(input);\n  } else {\n    throw new Error(\"Unsupported value type\");\n  }\n\n  return value;\n}\n"],"mappings":";;;;;AAIA,SAAgB,SAASA,KAAyB;AAChD,QAAO,OAAO,OAAO,QAAQ,YAAY,CAAC,MAAM,QAAQ,IAAI;AAC7D;;;;;AAMD,SAAgB,cAEdC,QACqB;AACrB,KAAI,CAAC,OAAQ,QAAO;AAEpB,KAAI,OAAO,WAAW,YAAY,OAAO,SAAS,EAChD,QAAO;AAET,KAAI,OAAO,WAAW,WACpB,QAAO;AAET,QAAO,SAAS,OAAO,IAAI,OAAO,KAAK,OAAO,CAAC,WAAW;AAC3D;;;;AAKD,SAAgB,MAAMC,OAAyB;AAC7C,KAAI,OAAO,UAAU,SACnB,QAAO,QAAQ,MAAM;UACZ,OAAO,UAAU,UAAU;EACpC,MAAM,cAAc,SAAS,OAAO,GAAG;AACvC,SACE,CAAC,OAAO,MAAM,YAAY,IAC1B,cAAc,MAAM,KACpB,YAAY,UAAU,KAAK;CAE9B;AAED,QAAO;AACR;;;;AAKD,SAAgB,QAAQA,OAAyB;AAC/C,KAAI,OAAO,UAAU,SACnB,QAAO,QAAQ,MAAM;UACZ,OAAO,UAAU,UAAU;EACpC,MAAM,cAAc,WAAW,MAAM;AACrC,SACE,CAAC,OAAO,MAAM,YAAY,IAC1B,cAAc,MAAM,KACpB,YAAY,UAAU,KAAK;CAE9B;AAED,QAAO;AACR;;;;;AAMD,SAAgB,SAASA,OAAyB;AAChD,QACE,OAAO,UAAU,aAChB,OAAO,MAAM,WAAW,MAAM,CAAC,IAAI,WAAW,MAAM,CAAC,UAAU,KAAK;AAExE;;;;AAKD,SAAgB,UAAUA,OAAyB;AACjD,QAAO,OAAO,UAAU;AACzB;;;;;;;AAQD,SAAgB,UAAUC,OAA2C;CACnE,IAAI;AACJ,KAAI,SAAS,MAAM,EACjB,QAAQ;UACC,MAAM,MAAM,EACrB,QAAQ,SAAS,OAAiB,GAAG;UAC5B,QAAQ,MAAM,EACvB,QAAQ,WAAW,MAAgB;UAC1B,UAAU,MAAM,EACzB,QAAQ,QAAQ,MAAM;KAEtB,OAAM,IAAI,MAAM;AAGlB,QAAO;AACR"}

package/dist/structured_query/utils.d.cts

@@ -0,0 +1,40 @@
+//#region src/structured_query/utils.d.ts
+/**
+ * Checks if the provided argument is an object and not an array.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+declare function isObject(obj: any): obj is object;
+/**
+ * Checks if a provided filter is empty. The filter can be a function, an
+ * object, a string, or undefined.
+ */
+declare function isFilterEmpty(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+filter: ((q: any) => any) | object | string | undefined): filter is undefined;
+/**
+ * Checks if the provided value is an integer.
+ */
+declare function isInt(value: unknown): boolean;
+/**
+ * Checks if the provided value is a floating-point number.
+ */
+declare function isFloat(value: unknown): boolean;
+/**
+ * Checks if the provided value is a string that cannot be parsed into a
+ * number.
+ */
+declare function isString(value: unknown): boolean;
+/**
+ * Checks if the provided value is a boolean.
+ */
+declare function isBoolean(value: unknown): boolean;
+/**
+ * Casts a value that might be string or number to actual string or number.
+ * Since LLM might return back an integer/float as a string, we need to cast
+ * it back to a number, as many vector databases can't handle number as string
+ * values as a comparator.
+ */
+declare function castValue(input: unknown): string | number | boolean;
+//#endregion
+export { castValue, isBoolean, isFilterEmpty, isFloat, isInt, isObject, isString };
+//# sourceMappingURL=utils.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.cts","names":["isObject","isFilterEmpty","isInt","isFloat","isString","isBoolean","castValue"],"sources":["../../src/structured_query/utils.d.ts"],"sourcesContent":["/**\n * Checks if the provided argument is an object and not an array.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport declare function isObject(obj: any): obj is object;\n/**\n * Checks if a provided filter is empty. The filter can be a function, an\n * object, a string, or undefined.\n */\nexport declare function isFilterEmpty(\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfilter: ((q: any) => any) | object | string | undefined): filter is undefined;\n/**\n * Checks if the provided value is an integer.\n */\nexport declare function isInt(value: unknown): boolean;\n/**\n * Checks if the provided value is a floating-point number.\n */\nexport declare function isFloat(value: unknown): boolean;\n/**\n * Checks if the provided value is a string that cannot be parsed into a\n * number.\n */\nexport declare function isString(value: unknown): boolean;\n/**\n * Checks if the provided value is a boolean.\n */\nexport declare function isBoolean(value: unknown): boolean;\n/**\n * Casts a value that might be string or number to actual string or number.\n * Since LLM might return back an integer/float as a string, we need to cast\n * it back to a number, as many vector databases can't handle number as string\n * values as a comparator.\n */\nexport declare function castValue(input: unknown): string | number | boolean;\n"],"mappings":";;AAIA;AAKA;AAMA;AAIwBG,iBAfAH,QAAAA,CAeO,GAAA,EAAA,GAAA,CAAA,EAAA,GAAA,IAAA,MAAA;AAK/B;AAIA;AAOA;;iBA1BwBC,aAAAA;;;;;;iBAMAC,KAAAA;;;;iBAIAC,OAAAA;;;;;iBAKAC,QAAAA;;;;iBAIAC,SAAAA;;;;;;;iBAOAC,SAAAA"}