langchain 0.0.76 → 0.0.77

package/dist/output_parsers/expression_type_handlers/member_expression_handler.cjs

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemberExpressionHandler = void 0;
+const base_js_1 = require("./base.cjs");
+class MemberExpressionHandler extends base_js_1.NodeHandler {
+    async accepts(node) {
+        if (base_js_1.ASTParser.isMemberExpression(node)) {
+            return node;
+        }
+        else {
+            return false;
+        }
+    }
+    async handle(node) {
+        if (!this.parentHandler) {
+            throw new Error("ArrayLiteralExpressionHandler must have a parent handler");
+        }
+        const { object, property } = node;
+        let prop;
+        if (base_js_1.ASTParser.isIdentifier(property)) {
+            prop = property.name.replace(/^["'](.+(?=["']$))["']$/, "$1");
+        }
+        else if (base_js_1.ASTParser.isStringLiteral(property)) {
+            prop = `${property.value}`.replace(/^["'](.+(?=["']$))["']$/, "$1");
+        }
+        else {
+            throw new Error("Invalid property key type");
+        }
+        let identifier;
+        if (base_js_1.ASTParser.isIdentifier(object)) {
+            identifier = object.name.replace(/^["'](.+(?=["']$))["']$/, "$1");
+        }
+        else if (base_js_1.ASTParser.isLiteral(object)) {
+            identifier = `${object.value}`.replace(/^["'](.+(?=["']$))["']$/, "$1");
+        }
+        else {
+            throw new Error("Invalid object type");
+        }
+        if (object.type !== "Identifier" && object.type !== "Literal") {
+            throw new Error("ArrayExpression is not supported");
+        }
+        return { type: "member_expression", identifier, property: prop };
+    }
+}
+exports.MemberExpressionHandler = MemberExpressionHandler;

package/dist/output_parsers/expression_type_handlers/member_expression_handler.d.ts

@@ -0,0 +1,7 @@
+import type { ESTree } from "meriyah";
+import { NodeHandler } from "./base.js";
+import { MemberExpressionType } from "./types.js";
+export declare class MemberExpressionHandler extends NodeHandler {
+    accepts(node: ESTree.Node): Promise<ESTree.MemberExpression | boolean>;
+    handle(node: ESTree.MemberExpression): Promise<MemberExpressionType>;
+}

package/dist/output_parsers/expression_type_handlers/member_expression_handler.js

@@ -0,0 +1,41 @@
+import { NodeHandler, ASTParser } from "./base.js";
+export class MemberExpressionHandler extends NodeHandler {
+    async accepts(node) {
+        if (ASTParser.isMemberExpression(node)) {
+            return node;
+        }
+        else {
+            return false;
+        }
+    }
+    async handle(node) {
+        if (!this.parentHandler) {
+            throw new Error("ArrayLiteralExpressionHandler must have a parent handler");
+        }
+        const { object, property } = node;
+        let prop;
+        if (ASTParser.isIdentifier(property)) {
+            prop = property.name.replace(/^["'](.+(?=["']$))["']$/, "$1");
+        }
+        else if (ASTParser.isStringLiteral(property)) {
+            prop = `${property.value}`.replace(/^["'](.+(?=["']$))["']$/, "$1");
+        }
+        else {
+            throw new Error("Invalid property key type");
+        }
+        let identifier;
+        if (ASTParser.isIdentifier(object)) {
+            identifier = object.name.replace(/^["'](.+(?=["']$))["']$/, "$1");
+        }
+        else if (ASTParser.isLiteral(object)) {
+            identifier = `${object.value}`.replace(/^["'](.+(?=["']$))["']$/, "$1");
+        }
+        else {
+            throw new Error("Invalid object type");
+        }
+        if (object.type !== "Identifier" && object.type !== "Literal") {
+            throw new Error("ArrayExpression is not supported");
+        }
+        return { type: "member_expression", identifier, property: prop };
+    }
+}

package/dist/output_parsers/expression_type_handlers/numeric_literal_handler.cjs

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NumericLiteralHandler = void 0;
+const base_js_1 = require("./base.cjs");
+class NumericLiteralHandler extends base_js_1.NodeHandler {
+    async accepts(node) {
+        if (base_js_1.ASTParser.isNumericLiteral(node)) {
+            return node;
+        }
+        else {
+            return false;
+        }
+    }
+    async handle(node) {
+        if (!this.parentHandler) {
+            throw new Error("ArrayLiteralExpressionHandler must have a parent handler");
+        }
+        return {
+            type: "numeric_literal",
+            value: Number(node.value),
+        };
+    }
+}
+exports.NumericLiteralHandler = NumericLiteralHandler;

package/dist/output_parsers/expression_type_handlers/numeric_literal_handler.d.ts

@@ -0,0 +1,7 @@
+import type { ESTree } from "meriyah";
+import { NodeHandler } from "./base.js";
+import { NumericLiteralType } from "./types.js";
+export declare class NumericLiteralHandler extends NodeHandler {
+    accepts(node: ESTree.Node): Promise<ESTree.Literal | boolean>;
+    handle(node: ESTree.Literal): Promise<NumericLiteralType>;
+}

package/dist/output_parsers/expression_type_handlers/numeric_literal_handler.js

@@ -0,0 +1,20 @@
+import { NodeHandler, ASTParser } from "./base.js";
+export class NumericLiteralHandler extends NodeHandler {
+    async accepts(node) {
+        if (ASTParser.isNumericLiteral(node)) {
+            return node;
+        }
+        else {
+            return false;
+        }
+    }
+    async handle(node) {
+        if (!this.parentHandler) {
+            throw new Error("ArrayLiteralExpressionHandler must have a parent handler");
+        }
+        return {
+            type: "numeric_literal",
+            value: Number(node.value),
+        };
+    }
+}

package/dist/output_parsers/expression_type_handlers/object_literal_expression_handler.cjs

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectLiteralExpressionHandler = void 0;
+const base_js_1 = require("./base.cjs");
+const property_assignment_handler_js_1 = require("./property_assignment_handler.cjs");
+class ObjectLiteralExpressionHandler extends base_js_1.NodeHandler {
+    async accepts(node) {
+        if (base_js_1.ASTParser.isObjectExpression(node)) {
+            return node;
+        }
+        else {
+            return false;
+        }
+    }
+    async handle(node) {
+        if (!this.parentHandler) {
+            throw new Error("ArrayLiteralExpressionHandler must have a parent handler");
+        }
+        const values = [];
+        const { properties } = node;
+        for (const property of properties) {
+            if (base_js_1.ASTParser.isProperty(property)) {
+                values.push(await new property_assignment_handler_js_1.PropertyAssignmentHandler(this.parentHandler).handle(property));
+            }
+        }
+        return { type: "object_literal", values };
+    }
+}
+exports.ObjectLiteralExpressionHandler = ObjectLiteralExpressionHandler;

package/dist/output_parsers/expression_type_handlers/object_literal_expression_handler.d.ts

@@ -0,0 +1,7 @@
+import type { ESTree } from "meriyah";
+import { NodeHandler } from "./base.js";
+import { ObjectLiteralType } from "./types.js";
+export declare class ObjectLiteralExpressionHandler extends NodeHandler {
+    accepts(node: ESTree.Node): Promise<ESTree.ObjectExpression | boolean>;
+    handle(node: ESTree.ObjectExpression): Promise<ObjectLiteralType>;
+}

package/dist/output_parsers/expression_type_handlers/object_literal_expression_handler.js

@@ -0,0 +1,25 @@
+import { NodeHandler, ASTParser } from "./base.js";
+import { PropertyAssignmentHandler } from "./property_assignment_handler.js";
+export class ObjectLiteralExpressionHandler extends NodeHandler {
+    async accepts(node) {
+        if (ASTParser.isObjectExpression(node)) {
+            return node;
+        }
+        else {
+            return false;
+        }
+    }
+    async handle(node) {
+        if (!this.parentHandler) {
+            throw new Error("ArrayLiteralExpressionHandler must have a parent handler");
+        }
+        const values = [];
+        const { properties } = node;
+        for (const property of properties) {
+            if (ASTParser.isProperty(property)) {
+                values.push(await new PropertyAssignmentHandler(this.parentHandler).handle(property));
+            }
+        }
+        return { type: "object_literal", values };
+    }
+}

package/dist/output_parsers/expression_type_handlers/property_assignment_handler.cjs

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PropertyAssignmentHandler = void 0;
+const base_js_1 = require("./base.cjs");
+class PropertyAssignmentHandler extends base_js_1.NodeHandler {
+    async accepts(node) {
+        if (base_js_1.ASTParser.isProperty(node)) {
+            return node;
+        }
+        else {
+            return false;
+        }
+    }
+    async handle(node) {
+        if (!this.parentHandler) {
+            throw new Error("ArrayLiteralExpressionHandler must have a parent handler");
+        }
+        let name;
+        if (base_js_1.ASTParser.isIdentifier(node.key)) {
+            name = node.key.name;
+        }
+        else if (base_js_1.ASTParser.isStringLiteral(node.key)) {
+            name = node.key.value;
+        }
+        else {
+            throw new Error("Invalid property key type");
+        }
+        if (!name) {
+            throw new Error("Invalid property key");
+        }
+        const identifier = `${name}`.replace(/^["'](.+(?=["']$))["']$/, "$1");
+        const value = await this.parentHandler.handle(node.value);
+        return { type: "property_assignment", identifier, value };
+    }
+}
+exports.PropertyAssignmentHandler = PropertyAssignmentHandler;

package/dist/output_parsers/expression_type_handlers/property_assignment_handler.d.ts

@@ -0,0 +1,7 @@
+import type { ESTree } from "meriyah";
+import { NodeHandler } from "./base.js";
+import { PropertyAssignmentType } from "./types.js";
+export declare class PropertyAssignmentHandler extends NodeHandler {
+    accepts(node: ESTree.Node): Promise<ESTree.Property | boolean>;
+    handle(node: ESTree.Property): Promise<PropertyAssignmentType>;
+}

package/dist/output_parsers/expression_type_handlers/property_assignment_handler.js

@@ -0,0 +1,32 @@
+import { NodeHandler, ASTParser } from "./base.js";
+export class PropertyAssignmentHandler extends NodeHandler {
+    async accepts(node) {
+        if (ASTParser.isProperty(node)) {
+            return node;
+        }
+        else {
+            return false;
+        }
+    }
+    async handle(node) {
+        if (!this.parentHandler) {
+            throw new Error("ArrayLiteralExpressionHandler must have a parent handler");
+        }
+        let name;
+        if (ASTParser.isIdentifier(node.key)) {
+            name = node.key.name;
+        }
+        else if (ASTParser.isStringLiteral(node.key)) {
+            name = node.key.value;
+        }
+        else {
+            throw new Error("Invalid property key type");
+        }
+        if (!name) {
+            throw new Error("Invalid property key");
+        }
+        const identifier = `${name}`.replace(/^["'](.+(?=["']$))["']$/, "$1");
+        const value = await this.parentHandler.handle(node.value);
+        return { type: "property_assignment", identifier, value };
+    }
+}

package/dist/output_parsers/expression_type_handlers/string_literal_handler.cjs

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringLiteralHandler = void 0;
+const base_js_1 = require("./base.cjs");
+class StringLiteralHandler extends base_js_1.NodeHandler {
+    async accepts(node) {
+        if (base_js_1.ASTParser.isStringLiteral(node)) {
+            return node;
+        }
+        else {
+            return false;
+        }
+    }
+    async handle(node) {
+        if (!this.parentHandler) {
+            throw new Error("ArrayLiteralExpressionHandler must have a parent handler");
+        }
+        const text = `${node.value}`.replace(/^["'](.+(?=["']$))["']$/, "$1");
+        return { type: "string_literal", value: text };
+    }
+}
+exports.StringLiteralHandler = StringLiteralHandler;

package/dist/output_parsers/expression_type_handlers/string_literal_handler.d.ts

@@ -0,0 +1,7 @@
+import type { ESTree } from "meriyah";
+import { NodeHandler } from "./base.js";
+import { StringLiteralType } from "./types.js";
+export declare class StringLiteralHandler extends NodeHandler {
+    accepts(node: ESTree.Node): Promise<ESTree.Literal | boolean>;
+    handle(node: ESTree.Literal): Promise<StringLiteralType>;
+}

package/dist/output_parsers/expression_type_handlers/string_literal_handler.js

@@ -0,0 +1,18 @@
+import { NodeHandler, ASTParser } from "./base.js";
+export class StringLiteralHandler extends NodeHandler {
+    async accepts(node) {
+        if (ASTParser.isStringLiteral(node)) {
+            return node;
+        }
+        else {
+            return false;
+        }
+    }
+    async handle(node) {
+        if (!this.parentHandler) {
+            throw new Error("ArrayLiteralExpressionHandler must have a parent handler");
+        }
+        const text = `${node.value}`.replace(/^["'](.+(?=["']$))["']$/, "$1");
+        return { type: "string_literal", value: text };
+    }
+}

package/dist/output_parsers/expression_type_handlers/types.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/output_parsers/expression_type_handlers/types.d.ts

@@ -0,0 +1,41 @@
+export type ArgumentsType = IdentifierType | StringLiteralType | NumericLiteralType | ArrayLiteralType | ObjectLiteralType | CallExpressionType | BooleanLiteralType;
+export type ParsedType = ArgumentsType | PropertyAssignmentType;
+export type ArrayLiteralType = {
+    type: "array_literal";
+    values: ArgumentsType[];
+};
+export type BooleanLiteralType = {
+    type: "boolean_literal";
+    value: boolean;
+};
+export type CallExpressionType = {
+    type: "call_expression";
+    funcCall: string | MemberExpressionType;
+    args?: ArgumentsType[];
+};
+export type NumericLiteralType = {
+    type: "numeric_literal";
+    value: number;
+};
+export type ObjectLiteralType = {
+    type: "object_literal";
+    values: PropertyAssignmentType[];
+};
+export type MemberExpressionType = {
+    type: "member_expression";
+    identifier: string;
+    property: string;
+};
+export type PropertyAssignmentType = {
+    type: "property_assignment";
+    identifier: string;
+    value: ArgumentsType;
+};
+export type StringLiteralType = {
+    type: "string_literal";
+    value: string;
+};
+export type IdentifierType = {
+    type: "identifier";
+    value: string;
+};

package/dist/output_parsers/expression_type_handlers/types.js

@@ -0,0 +1 @@
+export {};

package/dist/output_parsers/index.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CustomListOutputParser = exports.RouterOutputParser = exports.CombiningOutputParser = exports.OutputFixingParser = exports.JsonMarkdownStructuredOutputParser = exports.StructuredOutputParser = exports.RegexParser = exports.CommaSeparatedListOutputParser = exports.ListOutputParser = void 0;
+exports.CustomListOutputParser = exports.RouterOutputParser = exports.CombiningOutputParser = exports.OutputFixingParser = exports.JsonMarkdownStructuredOutputParser = exports.AsymmetricStructuredOutputParser = exports.StructuredOutputParser = exports.RegexParser = exports.CommaSeparatedListOutputParser = exports.ListOutputParser = void 0;
 var list_js_1 = require("./list.cjs");
 Object.defineProperty(exports, "ListOutputParser", { enumerable: true, get: function () { return list_js_1.ListOutputParser; } });
 Object.defineProperty(exports, "CommaSeparatedListOutputParser", { enumerable: true, get: function () { return list_js_1.CommaSeparatedListOutputParser; } });
@@ -8,6 +8,7 @@ var regex_js_1 = require("./regex.cjs");
 Object.defineProperty(exports, "RegexParser", { enumerable: true, get: function () { return regex_js_1.RegexParser; } });
 var structured_js_1 = require("./structured.cjs");
 Object.defineProperty(exports, "StructuredOutputParser", { enumerable: true, get: function () { return structured_js_1.StructuredOutputParser; } });
+Object.defineProperty(exports, "AsymmetricStructuredOutputParser", { enumerable: true, get: function () { return structured_js_1.AsymmetricStructuredOutputParser; } });
 Object.defineProperty(exports, "JsonMarkdownStructuredOutputParser", { enumerable: true, get: function () { return structured_js_1.JsonMarkdownStructuredOutputParser; } });
 var fix_js_1 = require("./fix.cjs");
 Object.defineProperty(exports, "OutputFixingParser", { enumerable: true, get: function () { return fix_js_1.OutputFixingParser; } });

package/dist/output_parsers/index.d.ts

@@ -1,6 +1,6 @@
 export { ListOutputParser, CommaSeparatedListOutputParser } from "./list.js";
 export { RegexParser } from "./regex.js";
-export { StructuredOutputParser, JsonMarkdownStructuredOutputParser, JsonMarkdownFormatInstructionsOptions, JsonMarkdownStructuredOutputParserInput, } from "./structured.js";
+export { StructuredOutputParser, AsymmetricStructuredOutputParser, JsonMarkdownStructuredOutputParser, JsonMarkdownFormatInstructionsOptions, JsonMarkdownStructuredOutputParserInput, } from "./structured.js";
 export { OutputFixingParser } from "./fix.js";
 export { CombiningOutputParser } from "./combining.js";
 export { RouterOutputParser, RouterOutputParserInput } from "./router.js";

package/dist/output_parsers/index.js

@@ -1,6 +1,6 @@
 export { ListOutputParser, CommaSeparatedListOutputParser } from "./list.js";
 export { RegexParser } from "./regex.js";
-export { StructuredOutputParser, JsonMarkdownStructuredOutputParser, } from "./structured.js";
+export { StructuredOutputParser, AsymmetricStructuredOutputParser, JsonMarkdownStructuredOutputParser, } from "./structured.js";
 export { OutputFixingParser } from "./fix.js";
 export { CombiningOutputParser } from "./combining.js";
 export { RouterOutputParser } from "./router.js";

package/dist/output_parsers/structured.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.JsonMarkdownStructuredOutputParser = exports.StructuredOutputParser = void 0;
+exports.AsymmetricStructuredOutputParser = exports.JsonMarkdownStructuredOutputParser = exports.StructuredOutputParser = void 0;
 const zod_1 = require("zod");
 const zod_to_json_schema_1 = require("zod-to-json-schema");
 const output_parser_js_1 = require("../schema/output_parser.cjs");
@@ -63,31 +63,89 @@ class JsonMarkdownStructuredOutputParser extends StructuredOutputParser {
     }
     _schemaToInstruction(schemaInput, indent = 2) {
         const schema = schemaInput;
-        let nullable = false;
-        if (Array.isArray(schema.type)) {
-            const [actualType, nullStr] = schema.type;
-            nullable = nullStr === "null";
-            schema.type = actualType;
-        }
-        if (schema.type === "object" && schema.properties) {
+        if ("type" in schema) {
+            let nullable = false;
+            let type;
+            if (Array.isArray(schema.type)) {
+                const nullIdx = schema.type.findIndex((type) => type === "null");
+                if (nullIdx !== -1) {
+                    nullable = true;
+                    schema.type.splice(nullIdx, 1);
+                }
+                type = schema.type.join(" | ");
+            }
+            else {
+                type = schema.type;
+            }
+            if (schema.type === "object" && schema.properties) {
+                const description = schema.description
+                    ? ` // ${schema.description}`
+                    : "";
+                const properties = Object.entries(schema.properties)
+                    .map(([key, value]) => {
+                    const isOptional = schema.required?.includes(key)
+                        ? ""
+                        : " (optional)";
+                    return `${" ".repeat(indent)}"${key}": ${this._schemaToInstruction(value, indent + 2)}${isOptional}`;
+                })
+                    .join("\n");
+                return `{\n${properties}\n${" ".repeat(indent - 2)}}${description}`;
+            }
+            if (schema.type === "array" && schema.items) {
+                const description = schema.description
+                    ? ` // ${schema.description}`
+                    : "";
+                return `array[\n${" ".repeat(indent)}${this._schemaToInstruction(schema.items, indent + 2)}\n${" ".repeat(indent - 2)}] ${description}`;
+            }
+            const isNullable = nullable ? " (nullable)" : "";
             const description = schema.description ? ` // ${schema.description}` : "";
-            const properties = Object.entries(schema.properties)
-                .map(([key, value]) => {
-                const isOptional = schema.required?.includes(key)
-                    ? ""
-                    : " (optional)";
-                return `${" ".repeat(indent)}"${key}": ${this._schemaToInstruction(value, indent + 2)}${isOptional}`;
-            })
-                .join("\n");
-            return `{\n${properties}\n${" ".repeat(indent - 2)}}${description}`;
+            return `${type}${description}${isNullable}`;
         }
-        if (schema.type === "array" && schema.items) {
-            const description = schema.description ? ` // ${schema.description}` : "";
-            return `array[\n${" ".repeat(indent)}${this._schemaToInstruction(schema.items)}\n${" ".repeat(indent - 2)}] ${description}`;
+        if ("anyOf" in schema) {
+            return schema.anyOf
+                .map((s) => this._schemaToInstruction(s, indent))
+                .join(`\n${" ".repeat(indent - 2)}`);
         }
-        const isNullable = nullable ? " (nullable)" : "";
-        const description = schema.description ? ` // ${schema.description}` : "";
-        return `${schema.type}${description}${isNullable}`;
+        throw new Error("unsupported schema type");
+    }
+    static fromZodSchema(schema) {
+        return new this(schema);
+    }
+    static fromNamesAndDescriptions(schemas) {
+        const zodSchema = zod_1.z.object(Object.fromEntries(Object.entries(schemas).map(([name, description]) => [name, zod_1.z.string().describe(description)])));
+        return new this(zodSchema);
     }
 }
 exports.JsonMarkdownStructuredOutputParser = JsonMarkdownStructuredOutputParser;
+class AsymmetricStructuredOutputParser extends output_parser_js_1.BaseOutputParser {
+    constructor(inputSchema) {
+        super();
+        Object.defineProperty(this, "inputSchema", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: inputSchema
+        });
+        Object.defineProperty(this, "structuredInputParser", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.structuredInputParser = new JsonMarkdownStructuredOutputParser(inputSchema);
+    }
+    async parse(text) {
+        let parsedInput;
+        try {
+            parsedInput = await this.structuredInputParser.parse(text);
+        }
+        catch (e) {
+            throw new output_parser_js_1.OutputParserException(`Failed to parse. Text: "${text}". Error: ${e}`, text);
+        }
+        return this.outputProcessor(parsedInput);
+    }
+    getFormatInstructions() {
+        return this.structuredInputParser.getFormatInstructions();
+    }
+}
+exports.AsymmetricStructuredOutputParser = AsymmetricStructuredOutputParser;

package/dist/output_parsers/structured.d.ts

@@ -25,4 +25,22 @@ export declare class StructuredOutputParser<T extends z.ZodTypeAny> extends Base
 export declare class JsonMarkdownStructuredOutputParser<T extends z.ZodTypeAny> extends StructuredOutputParser<T> {
     getFormatInstructions(options?: JsonMarkdownFormatInstructionsOptions): string;
     private _schemaToInstruction;
+    static fromZodSchema<T extends z.ZodTypeAny>(schema: T): JsonMarkdownStructuredOutputParser<T>;
+    static fromNamesAndDescriptions<S extends {
+        [key: string]: string;
+    }>(schemas: S): JsonMarkdownStructuredOutputParser<z.ZodObject<{
+        [k: string]: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        [x: string]: string;
+    }, {
+        [x: string]: string;
+    }>>;
+}
+export declare abstract class AsymmetricStructuredOutputParser<T extends z.ZodTypeAny, Y = unknown> extends BaseOutputParser<Y> {
+    inputSchema: T;
+    private structuredInputParser;
+    constructor(inputSchema: T);
+    abstract outputProcessor(input: z.infer<T>): Promise<Y>;
+    parse(text: string): Promise<Y>;
+    getFormatInstructions(): string;
 }