mindee 2.1.1 → 3.0.1

package/src/client.d.ts

@@ -1,27 +1,31 @@
 /// <reference types="node" />
-import { Input } from "./inputs";
+import { InputSource, PageOptions } from "./inputs";
 import { Response } from "./api";
-import { Document } from "./documents";
-import { DocumentConfig, responseSig } from "./documents/documentConfig";
+import { Document, DocumentSig } from "./documents";
+import { DocumentConfig } from "./documents/documentConfig";
 import { ReadStream } from "fs";
-declare type DocConfigs = Map<string[], DocumentConfig>;
+declare type DocConfigs = Map<string[], DocumentConfig<any>>;
 interface PredictOptions {
-    docType?: string;
-    username?: string;
-    cutPages?: boolean;
+    endpointName?: string;
+    accountName?: string;
     fullText?: boolean;
     cropper?: boolean;
+    pageOptions?: PageOptions;
 }
 declare class DocumentClient {
-    inputDoc: Input;
+    inputSource: InputSource;
     docConfigs: DocConfigs;
-    constructor(inputDoc: Input, docConfigs: DocConfigs);
-    parse<RespType extends Response<Document>>(responseClass: responseSig<RespType>, params?: PredictOptions): Promise<RespType>;
-    protected getDocType(responseClass: string): string;
+    constructor(inputSource: InputSource, docConfigs: DocConfigs);
+    /**
+     * Send a document to an endpoint and parse the predictions.
+     * @param documentClass
+     * @param params
+     */
+    parse<DocType extends Document>(documentClass: DocumentSig<DocType>, params?: PredictOptions): Promise<Response<DocType>>;
 }
 interface customConfigParams {
     accountName: string;
-    documentType: string;
+    endpointName: string;
     version?: string;
 }
 interface ClientOptions {
@@ -40,10 +44,40 @@ export declare class Client {
      */
     constructor(options?: ClientOptions);
     protected addStandardEndpoints(): void;
-    addEndpoint({ accountName, documentType, version, }: customConfigParams): this;
+    /**
+     * Add a custom endpoint to the client.
+     * @param accountName
+     * @param endpointName
+     * @param version
+     */
+    addEndpoint({ accountName, endpointName, version, }: customConfigParams): this;
+    /**
+     * Load an input document from a local path.
+     * @param inputPath
+     */
     docFromPath(inputPath: string): DocumentClient;
+    /**
+     * Load an input document from a base64 encoded string.
+     * @param inputString
+     * @param filename
+     */
     docFromBase64(inputString: string, filename: string): DocumentClient;
+    /**
+     * Load an input document from a `ReadStream`.
+     * @param inputStream
+     * @param filename
+     */
     docFromStream(inputStream: ReadStream, filename: string): DocumentClient;
+    /**
+     * Load an input document from a bytes string.
+     * @param inputBytes
+     * @param filename
+     */
     docFromBytes(inputBytes: string, filename: string): DocumentClient;
+    /**
+     * Load an input document from a URL.
+     * @param url
+     */
+    docFromUrl(url: string): DocumentClient;
 }
 export {};

package/src/client.js

@@ -7,26 +7,29 @@ const documents_1 = require("./documents");
 const documentConfig_1 = require("./documents/documentConfig");
 const handler_1 = require("./errors/handler");
 const logger_1 = require("./logger");
-const constants_1 = require("./constants");
 class DocumentClient {
-    constructor(inputDoc, docConfigs) {
-        this.inputDoc = inputDoc;
+    constructor(inputSource, docConfigs) {
+        this.inputSource = inputSource;
         this.docConfigs = docConfigs;
     }
-    async parse(responseClass, params = {
-        docType: "",
-        username: "",
-        cutPages: true,
+    /**
+     * Send a document to an endpoint and parse the predictions.
+     * @param documentClass
+     * @param params
+     */
+    async parse(documentClass, params = {
+        endpointName: "",
+        accountName: "",
         fullText: false,
         cropper: false,
+        pageOptions: undefined,
     }) {
         // seems like there should be a better way of doing this
         const fullText = params?.fullText !== undefined ? params.fullText : false;
         const cropper = params?.cropper !== undefined ? params.cropper : false;
-        const cutPages = params?.cutPages !== undefined ? params.cutPages : true;
-        const docType = params.docType === undefined || params.docType === ""
-            ? this.getDocType(responseClass.name)
-            : params.docType;
+        const docType = params.endpointName === undefined || params.endpointName === ""
+            ? documentClass.name
+            : params.endpointName;
         const found = [];
         this.docConfigs.forEach((config, configKey) => {
             if (configKey[1] === docType) {
@@ -40,24 +43,21 @@ class DocumentClient {
         if (found.length === 1) {
             configKey = found[0];
         }
-        else if (params.username) {
-            configKey = [params.username, docType];
+        else if (params.accountName) {
+            configKey = [params.accountName, docType];
         }
         const docConfig = this.docConfigs.get(configKey);
         if (docConfig === undefined) {
             // TODO: raise error printing all usernames
             throw `Couldn't find the config '${configKey}'`;
         }
-        return await docConfig.predict(responseClass, {
-            inputDoc: this.inputDoc,
+        return await docConfig.predict({
+            inputDoc: this.inputSource,
             includeWords: fullText,
-            cutPages: cutPages,
+            pageOptions: params.pageOptions,
             cropper: cropper,
         });
     }
-    getDocType(responseClass) {
-        return constants_1.ProductConfigs.getByResponseClassName(responseClass).docType;
-    }
 }
 /**
  * Mindee Client
@@ -81,27 +81,53 @@ class Client {
     }
     // TODO: init only those endpoints we actually need.
     addStandardEndpoints() {
-        this.docConfigs.set([api_1.STANDARD_API_OWNER, documents_1.DOC_TYPE_INVOICE], new documentConfig_1.InvoiceConfig(this.apiKey));
-        this.docConfigs.set([api_1.STANDARD_API_OWNER, documents_1.DOC_TYPE_RECEIPT], new documentConfig_1.ReceiptConfig(this.apiKey));
-        this.docConfigs.set([api_1.STANDARD_API_OWNER, documents_1.DOC_TYPE_FINANCIAL], new documentConfig_1.FinancialDocConfig(this.apiKey));
-        this.docConfigs.set([api_1.STANDARD_API_OWNER, documents_1.DOC_TYPE_PASSPORT], new documentConfig_1.PassportConfig(this.apiKey));
-        this.docConfigs.set([api_1.STANDARD_API_OWNER, documents_1.DOC_TYPE_CROPPER], new documentConfig_1.CropperConfig(this.apiKey));
+        this.docConfigs.set([api_1.STANDARD_API_OWNER, documents_1.FinancialDocumentV1.name], new documentConfig_1.FinancialDocV1Config(this.apiKey));
+        this.docConfigs.set([api_1.STANDARD_API_OWNER, documents_1.InvoiceV3.name], new documentConfig_1.DocumentConfig(documents_1.InvoiceV3, [
+            new api_1.StandardEndpoint("invoices", "3", this.apiKey),
+        ]));
+        this.docConfigs.set([api_1.STANDARD_API_OWNER, documents_1.ReceiptV3.name], new documentConfig_1.DocumentConfig(documents_1.ReceiptV3, [
+            new api_1.StandardEndpoint("expense_receipts", "3", this.apiKey),
+        ]));
+        this.docConfigs.set([api_1.STANDARD_API_OWNER, documents_1.ReceiptV4.name], new documentConfig_1.DocumentConfig(documents_1.ReceiptV4, [
+            new api_1.StandardEndpoint("expense_receipts", "4", this.apiKey),
+        ]));
+        this.docConfigs.set([api_1.STANDARD_API_OWNER, documents_1.PassportV1.name], new documentConfig_1.DocumentConfig(documents_1.PassportV1, [
+            new api_1.StandardEndpoint("passport", "1", this.apiKey),
+        ]));
+        this.docConfigs.set([api_1.STANDARD_API_OWNER, documents_1.CropperV1.name], new documentConfig_1.DocumentConfig(documents_1.CropperV1, [
+            new api_1.StandardEndpoint("cropper", "1", this.apiKey),
+        ]));
     }
-    addEndpoint({ accountName, documentType, version = "1", }) {
-        this.docConfigs.set([accountName, documentType], new documentConfig_1.CustomDocConfig({
+    /**
+     * Add a custom endpoint to the client.
+     * @param accountName
+     * @param endpointName
+     * @param version
+     */
+    addEndpoint({ accountName, endpointName, version = "1", }) {
+        this.docConfigs.set([accountName, endpointName], new documentConfig_1.CustomDocConfig({
             accountName: accountName,
-            documentType: documentType,
+            endpointName: endpointName,
             version: version,
             apiKey: this.apiKey,
         }));
         return this;
     }
+    /**
+     * Load an input document from a local path.
+     * @param inputPath
+     */
     docFromPath(inputPath) {
         const doc = new inputs_1.PathInput({
             inputPath: inputPath,
         });
         return new DocumentClient(doc, this.docConfigs);
     }
+    /**
+     * Load an input document from a base64 encoded string.
+     * @param inputString
+     * @param filename
+     */
     docFromBase64(inputString, filename) {
         const doc = new inputs_1.Base64Input({
             inputString: inputString,
@@ -109,6 +135,11 @@ class Client {
         });
         return new DocumentClient(doc, this.docConfigs);
     }
+    /**
+     * Load an input document from a `ReadStream`.
+     * @param inputStream
+     * @param filename
+     */
     docFromStream(inputStream, filename) {
         const doc = new inputs_1.StreamInput({
             inputStream: inputStream,
@@ -116,6 +147,11 @@ class Client {
         });
         return new DocumentClient(doc, this.docConfigs);
     }
+    /**
+     * Load an input document from a bytes string.
+     * @param inputBytes
+     * @param filename
+     */
     docFromBytes(inputBytes, filename) {
         const doc = new inputs_1.BytesInput({
             inputBytes: inputBytes,
@@ -123,5 +159,15 @@ class Client {
         });
         return new DocumentClient(doc, this.docConfigs);
     }
+    /**
+     * Load an input document from a URL.
+     * @param url
+     */
+    docFromUrl(url) {
+        const doc = new inputs_1.UrlInput({
+            url: url,
+        });
+        return new DocumentClient(doc, this.docConfigs);
+    }
 }
 exports.Client = Client;

package/src/documents/cropper/cropperV1.d.ts

@@ -0,0 +1,7 @@
+import { Document, DocumentConstructorProps } from "../document";
+import { CropperField } from "../../fields";
+export declare class CropperV1 extends Document {
+    cropping: CropperField[];
+    constructor({ prediction, orientation, inputSource, pageId, }: DocumentConstructorProps);
+    toString(): string;
+}

package/src/documents/{cropper.js → cropper/cropperV1.js}

@@ -1,11 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Cropper = void 0;
-const document_1 = require("./document");
-const fields_1 = require("../fields");
-class Cropper extends document_1.Document {
-    constructor({ prediction, orientation = undefined, inputFile = undefined, pageId = undefined, }) {
-        super({ inputFile, pageId, orientation });
+exports.CropperV1 = void 0;
+const document_1 = require("../document");
+const fields_1 = require("../../fields");
+class CropperV1 extends document_1.Document {
+    constructor({ prediction, orientation = undefined, inputSource = undefined, pageId = undefined, }) {
+        super({
+            inputSource: inputSource,
+            pageId: pageId,
+            orientation: orientation,
+        });
         this.cropping = [];
         if (pageId !== undefined) {
             prediction.cropping.forEach((crop) => {
@@ -25,7 +29,7 @@ Filename: ${this.filename}
 Cropping: ${cropping}
 ------------------------
 `;
-        return Cropper.cleanOutString(outStr);
+        return CropperV1.cleanOutString(outStr);
     }
 }
-exports.Cropper = Cropper;
+exports.CropperV1 = CropperV1;

package/src/documents/custom.d.ts

@@ -1,14 +1,10 @@
 import { Document, DocumentConstructorProps } from "./document";
 import { ClassificationField, ListField } from "../fields";
 import { stringDict } from "../fields";
-export interface CustomDocConstructorProps extends DocumentConstructorProps {
-    documentType: string;
-}
-export declare class CustomDocument extends Document {
+export declare class CustomV1 extends Document {
     fields: Map<string, ListField>;
     classifications: Map<string, ClassificationField>;
-    readonly documentType: string;
-    constructor({ inputFile, prediction, extras, orientation, pageId, documentType, }: CustomDocConstructorProps);
+    constructor({ inputSource, prediction, extras, orientation, pageId, documentType, }: DocumentConstructorProps);
     protected setField(fieldName: string, apiPrediction: stringDict, pageId: number | undefined): void;
     toString(): string;
 }

package/src/documents/custom.js

@@ -1,14 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CustomDocument = void 0;
+exports.CustomV1 = void 0;
 const document_1 = require("./document");
 const fields_1 = require("../fields");
-class CustomDocument extends document_1.Document {
-    constructor({ inputFile, prediction, extras = undefined, orientation = undefined, pageId, documentType, }) {
-        super({ inputFile, pageId, orientation, extras });
+class CustomV1 extends document_1.Document {
+    constructor({ inputSource, prediction, extras = undefined, orientation = undefined, pageId, documentType, }) {
+        super({
+            inputSource: inputSource,
+            pageId: pageId,
+            orientation: orientation,
+            extras: extras,
+            documentType: documentType,
+        });
         this.fields = new Map();
         this.classifications = new Map();
-        this.documentType = documentType;
         Object.keys(prediction).forEach((fieldName) => {
             this.setField(fieldName, prediction, pageId);
         });
@@ -33,7 +38,7 @@ class CustomDocument extends document_1.Document {
         }
     }
     toString() {
-        let outStr = `----- ${this.documentType} -----`;
+        let outStr = `----- ${this.docType} -----`;
         outStr += `\nFilename: ${this.filename}`.trimEnd();
         this.classifications.forEach((fieldData, name) => {
             outStr += `\n${name}: ${fieldData}`.trimEnd();
@@ -45,4 +50,4 @@ class CustomDocument extends document_1.Document {
         return outStr;
     }
 }
-exports.CustomDocument = CustomDocument;
+exports.CustomV1 = CustomV1;

package/src/documents/document.d.ts

@@ -1,5 +1,8 @@
-import { Input } from "../inputs";
+import { InputSource } from "../inputs";
 import { CropperField, FullText, OrientationField, stringDict } from "../fields";
+export declare type DocumentSig<DocType extends Document> = {
+    new ({ prediction, orientation, extras, inputSource, pageId, fullText, documentType, }: DocumentConstructorProps): DocType;
+};
 export interface DocumentConstructorProps extends BaseDocumentConstructorProps {
     /** JSON parsed prediction from HTTP response */
     prediction: stringDict;
@@ -10,11 +13,12 @@ interface BaseDocumentConstructorProps {
     /** Extras JSON */
     extras?: stringDict;
     /** input file given to parse the document */
-    inputFile?: Input;
+    inputSource?: InputSource;
     /** Page ID for page-level document */
     pageId?: number;
     /** full OCR extracted text */
     fullText?: FullText;
+    documentType?: string;
 }
 export declare class Document {
     checklist: {
@@ -27,7 +31,8 @@ export declare class Document {
     pageId?: number | undefined;
     orientation?: OrientationField;
     cropper: CropperField[];
-    constructor({ orientation, extras, inputFile, fullText, pageId, }: BaseDocumentConstructorProps);
+    readonly docType: string;
+    constructor({ orientation, extras, inputSource, fullText, pageId, documentType, }: BaseDocumentConstructorProps);
     clone(): any;
     /** return true if all checklist of the document if true */
     checkAll(): boolean;

package/src/documents/document.js

@@ -3,11 +3,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Document = void 0;
 const fields_1 = require("../fields");
 class Document {
-    constructor({ orientation = undefined, extras = undefined, inputFile = undefined, fullText = undefined, pageId = undefined, }) {
+    constructor({ orientation = undefined, extras = undefined, inputSource = undefined, fullText = undefined, pageId = undefined, documentType, }) {
         this.filename = "";
         this.cropper = [];
         this.filepath = undefined;
         this.pageId = pageId;
+        if (documentType === undefined || documentType === "") {
+            this.docType = Object.getPrototypeOf(this).constructor.name;
+        }
+        else {
+            this.docType = documentType;
+        }
         if (pageId !== undefined && orientation !== undefined) {
             this.orientation = new fields_1.OrientationField({
                 prediction: orientation,
@@ -24,10 +30,10 @@ class Document {
                 });
             }
         }
-        if (inputFile !== undefined) {
-            this.filepath = inputFile.filepath;
-            this.filename = inputFile.filename;
-            this.mimeType = inputFile.mimeType;
+        if (inputSource !== undefined) {
+            this.filepath = inputSource.filepath;
+            this.filename = inputSource.filename;
+            this.mimeType = inputSource.mimeType;
         }
         this.fullText = fullText;
         this.checklist = {};

package/src/documents/documentConfig.d.ts

@@ -1,48 +1,34 @@
-import { Input } from "../inputs";
-import { Response, Endpoint } from "../api";
-import { Document } from "./index";
-import { ResponseProps } from "../api/response";
+import { InputSource } from "../inputs";
+import { Response, Endpoint, predictResponse } from "../api";
+import { Document, FinancialDocumentV1, CustomV1, DocumentSig } from "./index";
+import { PageOptions } from "../inputs";
 interface CustomDocConstructor {
-    documentType: string;
+    endpointName: string;
     accountName: string;
     version: string;
     apiKey: string;
 }
-export declare type responseSig<RespType extends Response<Document>> = {
-    new ({ httpResponse, documentType, input, error }: ResponseProps): RespType;
-};
-export declare class DocumentConfig {
-    readonly documentType: string;
+export declare class DocumentConfig<DocType extends Document> {
+    readonly documentType: string | undefined;
     readonly endpoints: Array<Endpoint>;
-    constructor(documentType: string, endpoints: Array<Endpoint>);
-    predictRequest(inputDoc: Input, includeWords: boolean, cropping: boolean): Promise<unknown>;
-    buildResult<RespType extends Response<Document>>(responseType: responseSig<RespType>, inputFile: Input, response: any): RespType;
-    predict<RespType extends Response<Document>>(responseType: responseSig<RespType>, params: {
-        inputDoc: Input;
+    readonly documentClass: DocumentSig<DocType>;
+    constructor(documentClass: DocumentSig<DocType>, endpoints: Array<Endpoint>, documentType?: string);
+    protected predictRequest(inputDoc: InputSource, includeWords: boolean, cropping: boolean): Promise<predictResponse>;
+    buildResult(inputFile: InputSource, response: predictResponse): Response<DocType>;
+    predict(params: {
+        inputDoc: InputSource;
         includeWords: boolean;
-        cutPages: boolean;
+        pageOptions?: PageOptions;
         cropper: boolean;
-    }): Promise<RespType>;
-    cutDocPages(inputDoc: Input, cutPages: boolean): Promise<void>;
+    }): Promise<Response<DocType>>;
+    cutDocPages(inputDoc: InputSource, pageOptions: PageOptions): Promise<void>;
     protected checkApiKeys(): void;
 }
-export declare class InvoiceConfig extends DocumentConfig {
-    constructor(apiKey: string);
-}
-export declare class ReceiptConfig extends DocumentConfig {
-    constructor(apiKey: string);
-}
-export declare class FinancialDocConfig extends DocumentConfig {
-    constructor(apiKey: string);
-    predictRequest(inputDoc: Input, includeWords: boolean, cropping: boolean): Promise<unknown>;
-}
-export declare class PassportConfig extends DocumentConfig {
-    constructor(apiKey: string);
+export declare class CustomDocConfig extends DocumentConfig<CustomV1> {
+    constructor({ endpointName, accountName, version, apiKey, }: CustomDocConstructor);
 }
-export declare class CropperConfig extends DocumentConfig {
+export declare class FinancialDocV1Config extends DocumentConfig<FinancialDocumentV1> {
     constructor(apiKey: string);
-}
-export declare class CustomDocConfig extends DocumentConfig {
-    constructor({ documentType, accountName, version, apiKey, }: CustomDocConstructor);
+    protected predictRequest(inputDoc: InputSource, includeWords: boolean, cropping: boolean): Promise<predictResponse>;
 }
 export {};

package/src/documents/documentConfig.js

@@ -1,78 +1,77 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CustomDocConfig = exports.CropperConfig = exports.PassportConfig = exports.FinancialDocConfig = exports.ReceiptConfig = exports.InvoiceConfig = exports.DocumentConfig = void 0;
+exports.FinancialDocV1Config = exports.CustomDocConfig = exports.DocumentConfig = void 0;
 const api_1 = require("../api");
 const index_1 = require("./index");
 const handler_1 = require("../errors/handler");
 class DocumentConfig {
-    constructor(documentType, endpoints) {
+    constructor(documentClass, endpoints, documentType) {
         this.documentType = documentType;
         this.endpoints = endpoints;
+        this.documentClass = documentClass;
     }
     async predictRequest(inputDoc, includeWords, cropping) {
-        return await this.endpoints[0].predictRequest(inputDoc, includeWords, cropping);
+        return await this.endpoints[0].predictReqPost(inputDoc, includeWords, cropping);
     }
-    buildResult(responseType, inputFile, response) {
-        if (response.statusCode > 201) {
-            const errorMessage = JSON.stringify(response.data, null, 4);
-            handler_1.errorHandler.throw(new Error(`${this.endpoints[0].urlName} API ${response.statusCode} HTTP error: ${errorMessage}`));
-            return new responseType({
+    buildResult(inputFile, response) {
+        const statusCode = response.messageObj.statusCode;
+        if (statusCode === undefined || statusCode > 201) {
+            const errorMessage = JSON.stringify(response.data, null, 2);
+            handler_1.errorHandler.throw(new Error(`${this.endpoints[0].urlName} API ${statusCode} HTTP error: ${errorMessage}`));
+            return new api_1.Response(this.documentClass, {
                 httpResponse: response,
                 documentType: this.documentType,
                 input: inputFile,
                 error: true,
             });
         }
-        return new responseType({
+        return new api_1.Response(this.documentClass, {
             httpResponse: response,
             documentType: this.documentType,
             input: inputFile,
             error: false,
         });
     }
-    async predict(responseType, params) {
+    async predict(params) {
         this.checkApiKeys();
         await params.inputDoc.init();
-        await this.cutDocPages(params.inputDoc, params.cutPages);
+        if (params.pageOptions !== undefined) {
+            await this.cutDocPages(params.inputDoc, params.pageOptions);
+        }
         const response = await this.predictRequest(params.inputDoc, params.includeWords, params.cropper);
-        return this.buildResult(responseType, params.inputDoc, response);
+        return this.buildResult(params.inputDoc, response);
     }
-    async cutDocPages(inputDoc, cutPages) {
-        if (cutPages && inputDoc.isPdf()) {
-            await inputDoc.cutPdf();
+    async cutDocPages(inputDoc, pageOptions) {
+        if (inputDoc.isPdf()) {
+            await inputDoc.cutPdf(pageOptions);
         }
     }
     checkApiKeys() {
         this.endpoints.forEach((endpoint) => {
             if (!endpoint.apiKey) {
-                throw new Error(`Missing API key for '${endpoint.keyName}', check your Client configuration.
+                throw new Error(`Missing API key for '${this.documentType}', check your Client configuration.
 You can set this using the '${api_1.API_KEY_ENVVAR_NAME}' environment variable.\n`);
             }
         });
     }
 }
 exports.DocumentConfig = DocumentConfig;
-class InvoiceConfig extends DocumentConfig {
-    constructor(apiKey) {
-        const endpoints = [new api_1.InvoiceEndpoint(apiKey)];
-        super(index_1.DOC_TYPE_INVOICE, endpoints);
-    }
-}
-exports.InvoiceConfig = InvoiceConfig;
-class ReceiptConfig extends DocumentConfig {
-    constructor(apiKey) {
-        const endpoints = [new api_1.ReceiptEndpoint(apiKey)];
-        super(index_1.DOC_TYPE_RECEIPT, endpoints);
+class CustomDocConfig extends DocumentConfig {
+    constructor({ endpointName, accountName, version, apiKey, }) {
+        const endpoints = [
+            new api_1.CustomEndpoint(endpointName, accountName, version, apiKey),
+        ];
+        super(index_1.CustomV1, endpoints, endpointName);
     }
 }
-exports.ReceiptConfig = ReceiptConfig;
-class FinancialDocConfig extends DocumentConfig {
+exports.CustomDocConfig = CustomDocConfig;
+class FinancialDocV1Config extends DocumentConfig {
     constructor(apiKey) {
         const endpoints = [
-            new api_1.InvoiceEndpoint(apiKey),
-            new api_1.ReceiptEndpoint(apiKey),
+            new api_1.StandardEndpoint("invoices", "3", apiKey),
+            new api_1.StandardEndpoint("expense_receipts", "3", apiKey),
         ];
-        super(index_1.DOC_TYPE_FINANCIAL, endpoints);
+        super(index_1.FinancialDocumentV1, endpoints);
     }
     async predictRequest(inputDoc, includeWords, cropping) {
         let endpoint;
@@ -82,30 +81,7 @@ class FinancialDocConfig extends DocumentConfig {
         else {
             endpoint = this.endpoints[1];
         }
-        return await endpoint.predictRequest(inputDoc, includeWords, cropping);
-    }
-}
-exports.FinancialDocConfig = FinancialDocConfig;
-class PassportConfig extends DocumentConfig {
-    constructor(apiKey) {
-        const endpoints = [new api_1.PassportEndpoint(apiKey)];
-        super(index_1.DOC_TYPE_PASSPORT, endpoints);
-    }
-}
-exports.PassportConfig = PassportConfig;
-class CropperConfig extends DocumentConfig {
-    constructor(apiKey) {
-        const endpoints = [new api_1.CropperEndpoint(apiKey)];
-        super(index_1.DOC_TYPE_CROPPER, endpoints);
+        return await endpoint.predictReqPost(inputDoc, includeWords, cropping);
     }
 }
-exports.CropperConfig = CropperConfig;
-class CustomDocConfig extends DocumentConfig {
-    constructor({ documentType, accountName, version, apiKey, }) {
-        const endpoints = [
-            new api_1.CustomEndpoint(documentType, accountName, version, apiKey),
-        ];
-        super(documentType, endpoints);
-    }
-}
-exports.CustomDocConfig = CustomDocConfig;
+exports.FinancialDocV1Config = FinancialDocV1Config;

package/src/documents/{financialDocument.d.ts → financialDocument/financialDocumentV1.d.ts}

@@ -1,6 +1,6 @@
-import { Document, DocumentConstructorProps } from "./document";
-import { TaxField, Field, Amount, Locale, DateField as Date, CompanyRegistration } from "../fields";
-export declare class FinancialDocument extends Document {
+import { Document, DocumentConstructorProps } from "../document";
+import { TaxField, Field, Amount, Locale, DateField as Date, CompanyRegistration } from "../../fields";
+export declare class FinancialDocumentV1 extends Document {
     #private;
     pageId: number | undefined;
     locale: Locale;
@@ -20,6 +20,6 @@ export declare class FinancialDocument extends Document {
     customerAddress: Field;
     paymentDetails: Field[];
     customerCompanyRegistration: CompanyRegistration[];
-    constructor({ prediction, orientation, extras, inputFile, fullText, pageId, }: DocumentConstructorProps);
+    constructor({ prediction, orientation, extras, inputSource, fullText, pageId, }: DocumentConstructorProps);
     toString(): string;
 }