langchain 0.0.76 → 0.0.77

package/dist/callbacks/handlers/tracer_langchain.js

@@ -1,7 +1,8 @@
+import { AsyncCaller } from "../../util/async_caller.js";
 import { getRuntimeEnvironment } from "../../util/env.js";
 import { BaseTracer } from "./tracer.js";
 export class LangChainTracer extends BaseTracer {
-    constructor({ exampleId, tenantId, sessionName, sessionExtra, } = {}) {
+    constructor({ exampleId, tenantId, sessionName, sessionExtra, callerParams, } = {}) {
         super();
         Object.defineProperty(this, "name", {
             enumerable: true,
@@ -56,6 +57,12 @@ export class LangChainTracer extends BaseTracer {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "caller", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         // eslint-disable-next-line no-process-env
         if (typeof process !== "undefined" && process.env?.LANGCHAIN_API_KEY) {
             // eslint-disable-next-line no-process-env
@@ -76,6 +83,7 @@ export class LangChainTracer extends BaseTracer {
                 "default";
         this.sessionExtra = sessionExtra;
         this.exampleId = exampleId;
+        this.caller = new AsyncCaller(callerParams ?? {});
     }
     async ensureSession() {
         if (this.session) {
@@ -83,7 +91,7 @@ export class LangChainTracer extends BaseTracer {
         }
         const tenantId = await this.ensureTenantId();
         const endpoint = `${this.endpoint}/sessions?upsert=true`;
-        const res = await fetch(endpoint, {
+        const res = await this.caller.call(fetch, endpoint, {
             method: "POST",
             headers: this.headers,
             body: JSON.stringify({
@@ -105,7 +113,7 @@ export class LangChainTracer extends BaseTracer {
             return this.tenantId;
         }
         const endpoint = `${this.endpoint}/tenants`;
-        const response = await fetch(endpoint, {
+        const response = await this.caller.call(fetch, endpoint, {
             method: "GET",
             headers: this.headers,
         });
@@ -146,7 +154,7 @@ export class LangChainTracer extends BaseTracer {
     async persistRun(run) {
         const persistedRun = await this._convertToCreate(run, this.exampleId);
         const endpoint = `${this.endpoint}/runs`;
-        const response = await fetch(endpoint, {
+        const response = await this.caller.call(fetch, endpoint, {
             method: "POST",
             headers: this.headers,
             body: JSON.stringify(persistedRun),

package/dist/callbacks/manager.cjs

@@ -334,6 +334,10 @@ class CallbackManager extends BaseCallbackManager {
                 ? localHandlers.map(ensureHandler)
                 : localHandlers?.handlers, false);
         }
+        const verboseEnabled = (typeof process !== "undefined"
+            ? // eslint-disable-next-line no-process-env
+                process.env?.LANGCHAIN_VERBOSE !== undefined
+            : false) || options?.verbose;
         const tracingV2Enabled = typeof process !== "undefined"
             ? // eslint-disable-next-line no-process-env
                 process.env?.LANGCHAIN_TRACING_V2 !== undefined
@@ -343,11 +347,11 @@ class CallbackManager extends BaseCallbackManager {
                 ? // eslint-disable-next-line no-process-env
                     process.env?.LANGCHAIN_TRACING !== undefined
                 : false);
-        if (options?.verbose || tracingEnabled) {
+        if (verboseEnabled || tracingEnabled) {
             if (!callbackManager) {
                 callbackManager = new CallbackManager();
             }
-            if (options?.verbose &&
+            if (verboseEnabled &&
                 !callbackManager.handlers.some((handler) => handler.name === console_js_1.ConsoleCallbackHandler.prototype.name)) {
                 const consoleHandler = new console_js_1.ConsoleCallbackHandler();
                 callbackManager.addHandler(consoleHandler, true);

package/dist/callbacks/manager.js

@@ -327,6 +327,10 @@ export class CallbackManager extends BaseCallbackManager {
                 ? localHandlers.map(ensureHandler)
                 : localHandlers?.handlers, false);
         }
+        const verboseEnabled = (typeof process !== "undefined"
+            ? // eslint-disable-next-line no-process-env
+                process.env?.LANGCHAIN_VERBOSE !== undefined
+            : false) || options?.verbose;
         const tracingV2Enabled = typeof process !== "undefined"
             ? // eslint-disable-next-line no-process-env
                 process.env?.LANGCHAIN_TRACING_V2 !== undefined
@@ -336,11 +340,11 @@ export class CallbackManager extends BaseCallbackManager {
                 ? // eslint-disable-next-line no-process-env
                     process.env?.LANGCHAIN_TRACING !== undefined
                 : false);
-        if (options?.verbose || tracingEnabled) {
+        if (verboseEnabled || tracingEnabled) {
             if (!callbackManager) {
                 callbackManager = new CallbackManager();
             }
-            if (options?.verbose &&
+            if (verboseEnabled &&
                 !callbackManager.handlers.some((handler) => handler.name === ConsoleCallbackHandler.prototype.name)) {
                 const consoleHandler = new ConsoleCallbackHandler();
                 callbackManager.addHandler(consoleHandler, true);

package/dist/chains/query_constructor/index.cjs

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadQueryContstructorChain = exports.formatAttributeInfo = exports.StructuredQueryOutputParser = exports.EXAMPLE_PROMPT = exports.DEFAULT_SUFFIX = exports.DEFAULT_SCHEMA = exports.DEFAULT_PREFIX = exports.DEFAULT_EXAMPLES = exports.QueryTransformer = void 0;
+const zod_1 = require("zod");
+const parser_js_1 = require("./parser.cjs");
+Object.defineProperty(exports, "QueryTransformer", { enumerable: true, get: function () { return parser_js_1.QueryTransformer; } });
+const ir_js_1 = require("./ir.cjs");
+const prompt_js_1 = require("./prompt.cjs");
+Object.defineProperty(exports, "DEFAULT_EXAMPLES", { enumerable: true, get: function () { return prompt_js_1.DEFAULT_EXAMPLES; } });
+Object.defineProperty(exports, "DEFAULT_PREFIX", { enumerable: true, get: function () { return prompt_js_1.DEFAULT_PREFIX; } });
+Object.defineProperty(exports, "DEFAULT_SCHEMA", { enumerable: true, get: function () { return prompt_js_1.DEFAULT_SCHEMA; } });
+Object.defineProperty(exports, "DEFAULT_SUFFIX", { enumerable: true, get: function () { return prompt_js_1.DEFAULT_SUFFIX; } });
+Object.defineProperty(exports, "EXAMPLE_PROMPT", { enumerable: true, get: function () { return prompt_js_1.EXAMPLE_PROMPT; } });
+const template_js_1 = require("../../prompts/template.cjs");
+const llm_chain_js_1 = require("../llm_chain.cjs");
+const few_shot_js_1 = require("../../prompts/few_shot.cjs");
+const structured_js_1 = require("../../output_parsers/structured.cjs");
+const queryInputSchema = /* #__PURE__ */ zod_1.z.object({
+    query: /* #__PURE__ */ zod_1.z
+        .string()
+        .describe("text string to compare to document contents"),
+    filter: /* #__PURE__ */ zod_1.z
+        .string()
+        .optional()
+        .describe("logical condition statement for filtering documents"),
+});
+class StructuredQueryOutputParser extends structured_js_1.AsymmetricStructuredOutputParser {
+    constructor(parserFunction) {
+        super(queryInputSchema);
+        Object.defineProperty(this, "parserFunction", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: parserFunction
+        });
+    }
+    async outputProcessor(input) {
+        return this.parserFunction(input.query, input.filter);
+    }
+    static fromComponents(allowedComparators = [], allowedOperators = []) {
+        const queryTransformer = new parser_js_1.QueryTransformer(allowedComparators, allowedOperators);
+        return new StructuredQueryOutputParser(async (query, filter) => {
+            let myQuery = query;
+            if (myQuery.length === 0) {
+                myQuery = " ";
+            }
+            if (filter === "NO_FILTER" || filter === undefined) {
+                return new ir_js_1.StructuredQuery(query);
+            }
+            else {
+                const parsedFilter = await queryTransformer.parse(filter);
+                return new ir_js_1.StructuredQuery(query, parsedFilter);
+            }
+        });
+    }
+}
+exports.StructuredQueryOutputParser = StructuredQueryOutputParser;
+function formatAttributeInfo(info) {
+    const infoObj = info.reduce((acc, attr) => {
+        acc[attr.name] = {
+            type: attr.type,
+            description: attr.description,
+        };
+        return acc;
+    }, {});
+    return JSON.stringify(infoObj, null, 2)
+        .replaceAll("{", "{{")
+        .replaceAll("}", "}}");
+}
+exports.formatAttributeInfo = formatAttributeInfo;
+const defaultExample = prompt_js_1.DEFAULT_EXAMPLES.map((EXAMPLE) => EXAMPLE);
+function _getPrompt(documentContents, attributeInfo, allowedComparators, allowedOperators, examples = defaultExample) {
+    const myAllowedComparators = allowedComparators ?? Object.values(ir_js_1.Comparators);
+    const myAllowedOperators = allowedOperators ?? Object.values(ir_js_1.Operators);
+    const attributeJSON = formatAttributeInfo(attributeInfo);
+    const schema = (0, template_js_1.interpolateFString)(prompt_js_1.DEFAULT_SCHEMA, {
+        allowed_comparators: myAllowedComparators.join(" | "),
+        allowed_operators: myAllowedOperators.join(" | "),
+    });
+    const prefix = (0, template_js_1.interpolateFString)(prompt_js_1.DEFAULT_PREFIX, {
+        schema,
+    });
+    const suffix = (0, template_js_1.interpolateFString)(prompt_js_1.DEFAULT_SUFFIX, {
+        i: examples.length + 1,
+        content: documentContents,
+        attributes: attributeJSON,
+    });
+    const outputParser = StructuredQueryOutputParser.fromComponents(allowedComparators, allowedOperators);
+    return new few_shot_js_1.FewShotPromptTemplate({
+        examples,
+        examplePrompt: prompt_js_1.EXAMPLE_PROMPT,
+        inputVariables: ["query"],
+        suffix,
+        prefix,
+        outputParser,
+    });
+}
+function loadQueryContstructorChain(opts) {
+    const prompt = _getPrompt(opts.documentContents, opts.attributeInfo, opts.allowedComparators, opts.allowedOperators, opts.examples);
+    return new llm_chain_js_1.LLMChain({
+        llm: opts.llm,
+        prompt,
+    });
+}
+exports.loadQueryContstructorChain = loadQueryContstructorChain;

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

@@ -0,0 +1,37 @@
+import { z } from "zod";
+import { QueryTransformer, TraverseType } from "./parser.js";
+import { Comparator, Operator, StructuredQuery } from "./ir.js";
+import { InputValues } from "../../schema/index.js";
+import { DEFAULT_EXAMPLES, DEFAULT_PREFIX, DEFAULT_SCHEMA, DEFAULT_SUFFIX, EXAMPLE_PROMPT } from "./prompt.js";
+import { LLMChain } from "../llm_chain.js";
+import { BaseLanguageModel } from "../../base_language/index.js";
+import { AsymmetricStructuredOutputParser } from "../../output_parsers/structured.js";
+import { AttributeInfo } from "../../schema/query_constructor.js";
+export { QueryTransformer, TraverseType };
+export { DEFAULT_EXAMPLES, DEFAULT_PREFIX, DEFAULT_SCHEMA, DEFAULT_SUFFIX, EXAMPLE_PROMPT, };
+declare const queryInputSchema: z.ZodObject<{
+    query: z.ZodString;
+    filter: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    query: string;
+    filter?: string | undefined;
+}, {
+    query: string;
+    filter?: string | undefined;
+}>;
+export declare class StructuredQueryOutputParser extends AsymmetricStructuredOutputParser<typeof queryInputSchema, StructuredQuery> {
+    private parserFunction;
+    constructor(parserFunction: (query: string, filter?: string) => Promise<StructuredQuery>);
+    outputProcessor(input: z.infer<typeof queryInputSchema>): Promise<StructuredQuery>;
+    static fromComponents(allowedComparators?: Comparator[], allowedOperators?: Operator[]): StructuredQueryOutputParser;
+}
+export declare function formatAttributeInfo(info: AttributeInfo[]): string;
+export type QueryConstructorChainOptions = {
+    llm: BaseLanguageModel;
+    documentContents: string;
+    attributeInfo: AttributeInfo[];
+    examples?: InputValues[];
+    allowedComparators?: Comparator[];
+    allowedOperators?: Operator[];
+};
+export declare function loadQueryContstructorChain(opts: QueryConstructorChainOptions): LLMChain<string>;

package/dist/chains/query_constructor/index.js

@@ -0,0 +1,95 @@
+import { z } from "zod";
+import { QueryTransformer } from "./parser.js";
+import { Comparators, Operators, StructuredQuery, } from "./ir.js";
+import { DEFAULT_EXAMPLES, DEFAULT_PREFIX, DEFAULT_SCHEMA, DEFAULT_SUFFIX, EXAMPLE_PROMPT, } from "./prompt.js";
+import { interpolateFString } from "../../prompts/template.js";
+import { LLMChain } from "../llm_chain.js";
+import { FewShotPromptTemplate } from "../../prompts/few_shot.js";
+import { AsymmetricStructuredOutputParser } from "../../output_parsers/structured.js";
+export { QueryTransformer };
+export { DEFAULT_EXAMPLES, DEFAULT_PREFIX, DEFAULT_SCHEMA, DEFAULT_SUFFIX, EXAMPLE_PROMPT, };
+const queryInputSchema = /* #__PURE__ */ z.object({
+    query: /* #__PURE__ */ z
+        .string()
+        .describe("text string to compare to document contents"),
+    filter: /* #__PURE__ */ z
+        .string()
+        .optional()
+        .describe("logical condition statement for filtering documents"),
+});
+export class StructuredQueryOutputParser extends AsymmetricStructuredOutputParser {
+    constructor(parserFunction) {
+        super(queryInputSchema);
+        Object.defineProperty(this, "parserFunction", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: parserFunction
+        });
+    }
+    async outputProcessor(input) {
+        return this.parserFunction(input.query, input.filter);
+    }
+    static fromComponents(allowedComparators = [], allowedOperators = []) {
+        const queryTransformer = new QueryTransformer(allowedComparators, allowedOperators);
+        return new StructuredQueryOutputParser(async (query, filter) => {
+            let myQuery = query;
+            if (myQuery.length === 0) {
+                myQuery = " ";
+            }
+            if (filter === "NO_FILTER" || filter === undefined) {
+                return new StructuredQuery(query);
+            }
+            else {
+                const parsedFilter = await queryTransformer.parse(filter);
+                return new StructuredQuery(query, parsedFilter);
+            }
+        });
+    }
+}
+export function formatAttributeInfo(info) {
+    const infoObj = info.reduce((acc, attr) => {
+        acc[attr.name] = {
+            type: attr.type,
+            description: attr.description,
+        };
+        return acc;
+    }, {});
+    return JSON.stringify(infoObj, null, 2)
+        .replaceAll("{", "{{")
+        .replaceAll("}", "}}");
+}
+const defaultExample = DEFAULT_EXAMPLES.map((EXAMPLE) => EXAMPLE);
+function _getPrompt(documentContents, attributeInfo, allowedComparators, allowedOperators, examples = defaultExample) {
+    const myAllowedComparators = allowedComparators ?? Object.values(Comparators);
+    const myAllowedOperators = allowedOperators ?? Object.values(Operators);
+    const attributeJSON = formatAttributeInfo(attributeInfo);
+    const schema = interpolateFString(DEFAULT_SCHEMA, {
+        allowed_comparators: myAllowedComparators.join(" | "),
+        allowed_operators: myAllowedOperators.join(" | "),
+    });
+    const prefix = interpolateFString(DEFAULT_PREFIX, {
+        schema,
+    });
+    const suffix = interpolateFString(DEFAULT_SUFFIX, {
+        i: examples.length + 1,
+        content: documentContents,
+        attributes: attributeJSON,
+    });
+    const outputParser = StructuredQueryOutputParser.fromComponents(allowedComparators, allowedOperators);
+    return new FewShotPromptTemplate({
+        examples,
+        examplePrompt: EXAMPLE_PROMPT,
+        inputVariables: ["query"],
+        suffix,
+        prefix,
+        outputParser,
+    });
+}
+export function loadQueryContstructorChain(opts) {
+    const prompt = _getPrompt(opts.documentContents, opts.attributeInfo, opts.allowedComparators, opts.allowedOperators, opts.examples);
+    return new LLMChain({
+        llm: opts.llm,
+        prompt,
+    });
+}

package/dist/chains/query_constructor/ir.cjs

@@ -0,0 +1,116 @@
+"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",
+};
+exports.Comparators = {
+    eq: "eq",
+    lt: "lt",
+    gt: "gt",
+    lte: "lte",
+    gte: "gte",
+};
+class Visitor {
+}
+exports.Visitor = Visitor;
+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;
+class FilterDirective extends Expression {
+}
+exports.FilterDirective = FilterDirective;
+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 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 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"
+        });
+    }
+}
+exports.StructuredQuery = StructuredQuery;

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

@@ -0,0 +1,60 @@
+export type AND = "and";
+export type OR = "or";
+export type NOT = "not";
+export type Operator = AND | OR | NOT;
+export type EQ = "eq";
+export type LT = "lt";
+export type GT = "gt";
+export type LTE = "lte";
+export type GTE = "gte";
+export type Comparator = EQ | LT | GT | LTE | GTE;
+export declare const Operators: {
+    [key: string]: Operator;
+};
+export declare const Comparators: {
+    [key: string]: Comparator;
+};
+export type VisitorResult = VisitorOperationResult | VisitorComparisonResult | VisitorStructuredQueryResult;
+export type VisitorOperationResult = {
+    [operator: string]: VisitorResult[];
+};
+export type VisitorComparisonResult = {
+    [attr: string]: {
+        [comparator: string]: string | number;
+    };
+};
+export type VisitorStructuredQueryResult = {
+    filter?: VisitorStructuredQueryResult | VisitorComparisonResult | VisitorOperationResult;
+};
+export declare abstract class Visitor {
+    abstract allowedOperators: Operator[];
+    abstract allowedComparators: Comparator[];
+    abstract visitOperation(operation: Operation): VisitorOperationResult;
+    abstract visitComparison(comparison: Comparison): VisitorComparisonResult;
+    abstract visitStructuredQuery(structuredQuery: StructuredQuery): VisitorStructuredQueryResult;
+}
+export declare abstract class Expression {
+    abstract exprName: "Operation" | "Comparison" | "StructuredQuery";
+    accept(visitor: Visitor): VisitorOperationResult | VisitorComparisonResult | VisitorStructuredQueryResult;
+}
+export declare abstract class FilterDirective extends Expression {
+}
+export declare class Comparison extends FilterDirective {
+    comparator: Comparator;
+    attribute: string;
+    value: string | number;
+    exprName: "Comparison";
+    constructor(comparator: Comparator, attribute: string, value: string | number);
+}
+export declare class Operation extends FilterDirective {
+    operator: Operator;
+    args?: FilterDirective[] | undefined;
+    exprName: "Operation";
+    constructor(operator: Operator, args?: FilterDirective[] | undefined);
+}
+export declare class StructuredQuery extends Expression {
+    query: string;
+    filter?: FilterDirective | undefined;
+    exprName: "StructuredQuery";
+    constructor(query: string, filter?: FilterDirective | undefined);
+}

package/dist/chains/query_constructor/ir.js

@@ -0,0 +1,107 @@
+export const Operators = {
+    and: "and",
+    or: "or",
+    not: "not",
+};
+export const Comparators = {
+    eq: "eq",
+    lt: "lt",
+    gt: "gt",
+    lte: "lte",
+    gte: "gte",
+};
+export class Visitor {
+}
+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");
+        }
+    }
+}
+export class FilterDirective extends Expression {
+}
+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"
+        });
+    }
+}
+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"
+        });
+    }
+}
+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"
+        });
+    }
+}