mindee 2.1.1 → 3.0.0

package/src/documents/receipt/tax.d.ts

@@ -0,0 +1,25 @@
+import { TaxField } from "../../fields";
+interface ReceiptTaxConstructor {
+    prediction: any;
+    valueKey?: string;
+    rateKey?: string;
+    codeKey?: string;
+    basisKey?: string;
+    reconstructed?: boolean;
+    pageId?: number;
+}
+export declare class ReceiptTaxField extends TaxField {
+    /**  The tax base */
+    basis?: number;
+    /**
+     * @param {Object} prediction - Prediction object from HTTP response
+     * @param {String} valueKey - Key to use in the prediction dict to get the tax value
+     * @param {String} rateKey - Key to use to get the tax rate in the prediction dict
+     * @param {String} codeKey - Key to use to get the tax code in the prediction dict
+     * @param {Boolean} reconstructed - Does the object is reconstructed (not extracted by the API)
+     * @param {Integer} pageNumber - Page ID for multi-page document
+     */
+    constructor({ prediction, valueKey, rateKey, codeKey, basisKey, reconstructed, pageId, }: ReceiptTaxConstructor);
+    toString(): string;
+}
+export {};

package/src/documents/receipt/tax.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReceiptTaxField = void 0;
+const fields_1 = require("../../fields");
+const amount_1 = require("../../fields/amount");
+class ReceiptTaxField extends fields_1.TaxField {
+    /**
+     * @param {Object} prediction - Prediction object from HTTP response
+     * @param {String} valueKey - Key to use in the prediction dict to get the tax value
+     * @param {String} rateKey - Key to use to get the tax rate in the prediction dict
+     * @param {String} codeKey - Key to use to get the tax code in the prediction dict
+     * @param {Boolean} reconstructed - Does the object is reconstructed (not extracted by the API)
+     * @param {Integer} pageNumber - Page ID for multi-page document
+     */
+    constructor({ prediction, valueKey = "value", rateKey = "rate", codeKey = "code", basisKey = "basis", reconstructed = false, pageId = undefined, }) {
+        super({ prediction, valueKey, rateKey, codeKey, reconstructed, pageId });
+        /**  The tax base */
+        this.basis = undefined;
+        this.basis = parseFloat(prediction[basisKey]);
+        if (isNaN(this.basis))
+            this.basis = undefined;
+    }
+    toString() {
+        let outStr = "";
+        if (this.value !== undefined) {
+            outStr += `${(0, amount_1.floatToString)(this.value)}`;
+        }
+        if (this.rate !== undefined) {
+            outStr += ` ${(0, amount_1.floatToString)(this.rate)}%`;
+        }
+        if (this.code !== undefined) {
+            outStr += ` ${this.code}`;
+        }
+        if (this.basis !== undefined) {
+            outStr += ` ${this.basis}`;
+        }
+        return outStr.trim();
+    }
+}
+exports.ReceiptTaxField = ReceiptTaxField;

package/src/documents/us/bankCheck/bankCheckV1.d.ts

@@ -0,0 +1,3 @@
+import { Document } from "../../document";
+export declare class BankCheckV1 extends Document {
+}

package/src/documents/us/bankCheck/bankCheckV1.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BankCheckV1 = void 0;
+const document_1 = require("../../document");
+class BankCheckV1 extends document_1.Document {
+}
+exports.BankCheckV1 = BankCheckV1;

package/src/errors/MindeeError.d.ts

@@ -0,0 +1,3 @@
+export declare class MindeeError extends Error {
+    constructor(message: string);
+}

package/src/errors/MindeeError.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MindeeError = void 0;
+class MindeeError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "MindeeError";
+    }
+}
+exports.MindeeError = MindeeError;

package/src/errors/index.d.ts

@@ -0,0 +1 @@
+export { MindeeError } from "./MindeeError";

package/src/errors/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MindeeError = void 0;
+var MindeeError_1 = require("./MindeeError");
+Object.defineProperty(exports, "MindeeError", { enumerable: true, get: function () { return MindeeError_1.MindeeError; } });

package/src/fields/{customDocs.d.ts → apiBuilder.d.ts}

@@ -2,6 +2,10 @@ import { FieldConstructor, stringDict } from "./field";
 import { Polygon } from "../geometry";
 export declare class ClassificationField {
     value: string;
+    /**
+     * The confidence score of the prediction.
+     * Note: Score is calculated on **word selection**, not its textual content (OCR).
+     */
     confidence: number;
     constructor({ prediction }: {
         prediction: stringDict;
@@ -34,7 +38,7 @@ export declare class ListField {
     /** True if the field was reconstructed or computed using other fields. */
     reconstructed: boolean;
     /** The document page on which the information was found. */
-    pageId?: number;
+    pageId: number;
     constructor({ prediction, reconstructed, pageId }: FieldConstructor);
     contentsList(): Array<any>;
     contentsString(separator?: string): string;

package/src/fields/index.d.ts

@@ -5,7 +5,7 @@ export { Locale } from "./locale";
 export { Amount } from "./amount";
 export { DateField } from "./date";
 export { BaseField, stringDict, Field } from "./field";
-export { ListField, ListFieldValue, ClassificationField } from "./customDocs";
+export { ListField, ListFieldValue, ClassificationField } from "./apiBuilder";
 export { FullText } from "./fullText";
 export { CompanyRegistration } from "./companyRegistration";
 export { CropperField } from "./cropper";

package/src/fields/index.js

@@ -16,10 +16,10 @@ Object.defineProperty(exports, "DateField", { enumerable: true, get: function ()
 var field_1 = require("./field");
 Object.defineProperty(exports, "BaseField", { enumerable: true, get: function () { return field_1.BaseField; } });
 Object.defineProperty(exports, "Field", { enumerable: true, get: function () { return field_1.Field; } });
-var customDocs_1 = require("./customDocs");
-Object.defineProperty(exports, "ListField", { enumerable: true, get: function () { return customDocs_1.ListField; } });
-Object.defineProperty(exports, "ListFieldValue", { enumerable: true, get: function () { return customDocs_1.ListFieldValue; } });
-Object.defineProperty(exports, "ClassificationField", { enumerable: true, get: function () { return customDocs_1.ClassificationField; } });
+var apiBuilder_1 = require("./apiBuilder");
+Object.defineProperty(exports, "ListField", { enumerable: true, get: function () { return apiBuilder_1.ListField; } });
+Object.defineProperty(exports, "ListFieldValue", { enumerable: true, get: function () { return apiBuilder_1.ListFieldValue; } });
+Object.defineProperty(exports, "ClassificationField", { enumerable: true, get: function () { return apiBuilder_1.ClassificationField; } });
 var fullText_1 = require("./fullText");
 Object.defineProperty(exports, "FullText", { enumerable: true, get: function () { return fullText_1.FullText; } });
 var companyRegistration_1 = require("./companyRegistration");

package/src/index.d.ts

@@ -1,2 +1,3 @@
-export { Response, FinancialDocResponse, InvoiceResponse, PassportResponse, ReceiptResponse, CustomResponse, CropperResponse, } from "./api";
+export { CustomV1, FinancialDocumentV1, InvoiceV3, PassportV1, ReceiptV3, ReceiptV4, CropperV1, } from "./documents";
 export { Client } from "./client";
+export { PageOptionsOperation } from "./inputs";

package/src/index.js

@@ -1,13 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Client = exports.CropperResponse = exports.CustomResponse = exports.ReceiptResponse = exports.PassportResponse = exports.InvoiceResponse = exports.FinancialDocResponse = exports.Response = void 0;
-var api_1 = require("./api");
-Object.defineProperty(exports, "Response", { enumerable: true, get: function () { return api_1.Response; } });
-Object.defineProperty(exports, "FinancialDocResponse", { enumerable: true, get: function () { return api_1.FinancialDocResponse; } });
-Object.defineProperty(exports, "InvoiceResponse", { enumerable: true, get: function () { return api_1.InvoiceResponse; } });
-Object.defineProperty(exports, "PassportResponse", { enumerable: true, get: function () { return api_1.PassportResponse; } });
-Object.defineProperty(exports, "ReceiptResponse", { enumerable: true, get: function () { return api_1.ReceiptResponse; } });
-Object.defineProperty(exports, "CustomResponse", { enumerable: true, get: function () { return api_1.CustomResponse; } });
-Object.defineProperty(exports, "CropperResponse", { enumerable: true, get: function () { return api_1.CropperResponse; } });
+exports.PageOptionsOperation = exports.Client = exports.CropperV1 = exports.ReceiptV4 = exports.ReceiptV3 = exports.PassportV1 = exports.InvoiceV3 = exports.FinancialDocumentV1 = exports.CustomV1 = void 0;
+var documents_1 = require("./documents");
+Object.defineProperty(exports, "CustomV1", { enumerable: true, get: function () { return documents_1.CustomV1; } });
+Object.defineProperty(exports, "FinancialDocumentV1", { enumerable: true, get: function () { return documents_1.FinancialDocumentV1; } });
+Object.defineProperty(exports, "InvoiceV3", { enumerable: true, get: function () { return documents_1.InvoiceV3; } });
+Object.defineProperty(exports, "PassportV1", { enumerable: true, get: function () { return documents_1.PassportV1; } });
+Object.defineProperty(exports, "ReceiptV3", { enumerable: true, get: function () { return documents_1.ReceiptV3; } });
+Object.defineProperty(exports, "ReceiptV4", { enumerable: true, get: function () { return documents_1.ReceiptV4; } });
+Object.defineProperty(exports, "CropperV1", { enumerable: true, get: function () { return documents_1.CropperV1; } });
 var client_1 = require("./client");
 Object.defineProperty(exports, "Client", { enumerable: true, get: function () { return client_1.Client; } });
+var inputs_1 = require("./inputs");
+Object.defineProperty(exports, "PageOptionsOperation", { enumerable: true, get: function () { return inputs_1.PageOptionsOperation; } });

package/src/inputs/base.d.ts

@@ -0,0 +1,33 @@
+/// <reference types="node" />
+import { PageOptions } from "./pageOptions";
+interface InputProps {
+    inputType: string;
+}
+export declare const INPUT_TYPE_STREAM = "stream";
+export declare const INPUT_TYPE_BASE64 = "base64";
+export declare const INPUT_TYPE_BYTES = "bytes";
+export declare const INPUT_TYPE_PATH = "path";
+export declare const INPUT_TYPE_URL = "URL";
+export declare class InputSource {
+    inputType: string;
+    filename: string;
+    filepath?: string;
+    mimeType: string;
+    fileObject: Buffer | string;
+    /**
+     * @param {String} inputType - the type of input used in file ("base64", "path", "dummy").
+     *                             NB: dummy is only used for tests purposes
+     * @param {Boolean} cutPages
+     * NB: Because of async calls, init() should be called after creating the object
+     */
+    constructor({ inputType }: InputProps);
+    init(): Promise<void>;
+    isPdf(): boolean;
+    checkMimetype(): Promise<string>;
+    /**
+     * Merge PDF pages.
+     * @param pageOptions
+     */
+    cutPdf(pageOptions: PageOptions): Promise<void>;
+}
+export {};

package/src/inputs/base.js

@@ -0,0 +1,116 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InputSource = exports.INPUT_TYPE_URL = exports.INPUT_TYPE_PATH = exports.INPUT_TYPE_BYTES = exports.INPUT_TYPE_BASE64 = exports.INPUT_TYPE_STREAM = void 0;
+const fileType = __importStar(require("file-type"));
+const path = __importStar(require("path"));
+const pdf_1 = require("../pdf");
+const logger_1 = require("../logger");
+const handler_1 = require("../errors/handler");
+exports.INPUT_TYPE_STREAM = "stream";
+exports.INPUT_TYPE_BASE64 = "base64";
+exports.INPUT_TYPE_BYTES = "bytes";
+exports.INPUT_TYPE_PATH = "path";
+exports.INPUT_TYPE_URL = "URL";
+const MIMETYPES = new Map([
+    [".pdf", "application/pdf"],
+    [".heic", "image/heic"],
+    [".jpg", "image/jpeg"],
+    [".jpeg", "image/jpeg"],
+    [".png", "image/png"],
+    [".tif", "image/tiff"],
+    [".tiff", "image/tiff"],
+    [".webp", "image/webp"],
+]);
+const ALLOWED_INPUT_TYPES = [
+    exports.INPUT_TYPE_STREAM,
+    exports.INPUT_TYPE_BASE64,
+    exports.INPUT_TYPE_BYTES,
+    exports.INPUT_TYPE_PATH,
+    exports.INPUT_TYPE_URL,
+];
+class InputSource {
+    /**
+     * @param {String} inputType - the type of input used in file ("base64", "path", "dummy").
+     *                             NB: dummy is only used for tests purposes
+     * @param {Boolean} cutPages
+     * NB: Because of async calls, init() should be called after creating the object
+     */
+    constructor({ inputType }) {
+        this.filename = "";
+        this.mimeType = "";
+        // Check if inputType is valid
+        if (!ALLOWED_INPUT_TYPES.includes(inputType)) {
+            const allowed = Array.from(ALLOWED_INPUT_TYPES.keys()).join(", ");
+            handler_1.errorHandler.throw(new Error(`Invalid input type, must be one of ${allowed}.`));
+        }
+        this.inputType = inputType;
+        logger_1.logger.debug(`Loading file from: ${inputType}`);
+    }
+    async init() {
+        throw new Error("not Implemented");
+    }
+    isPdf() {
+        return this.mimeType === "application/pdf";
+    }
+    async checkMimetype() {
+        if (!(this.fileObject instanceof Buffer)) {
+            throw new Error(`MIME type cannot be verified on input source of type ${this.inputType}.`);
+        }
+        let mimeType;
+        const fileExt = path.extname(this.filename);
+        if (fileExt) {
+            mimeType = MIMETYPES.get(fileExt.toLowerCase()) || "";
+        }
+        else {
+            const guess = await fileType.fromBuffer(this.fileObject);
+            if (guess !== undefined) {
+                mimeType = guess.mime;
+            }
+            else {
+                throw "Could not determine the MIME type of the file";
+            }
+        }
+        if (!mimeType) {
+            const allowed = Array.from(MIMETYPES.keys()).join(", ");
+            const err = new Error(`Invalid file type, must be one of ${allowed}.`);
+            handler_1.errorHandler.throw(err);
+        }
+        logger_1.logger.debug(`File is of type: ${mimeType}`);
+        return mimeType;
+    }
+    /**
+     * Merge PDF pages.
+     * @param pageOptions
+     */
+    async cutPdf(pageOptions) {
+        if (!(this.fileObject instanceof Buffer)) {
+            throw new Error(`Cannot modify an input source of type ${this.inputType}.`);
+        }
+        const processedPdf = await (0, pdf_1.extractPages)(this.fileObject, pageOptions);
+        this.fileObject = processedPdf.file;
+    }
+}
+exports.InputSource = InputSource;

package/src/inputs/index.d.ts

@@ -0,0 +1,3 @@
+export { PageOptions, PageOptionsOperation } from "./pageOptions";
+export { Base64Input, BytesInput, PathInput, StreamInput, UrlInput, } from "./sources";
+export { InputSource, INPUT_TYPE_BASE64, INPUT_TYPE_BYTES, INPUT_TYPE_PATH, INPUT_TYPE_STREAM, } from "./base";

package/src/inputs/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INPUT_TYPE_STREAM = exports.INPUT_TYPE_PATH = exports.INPUT_TYPE_BYTES = exports.INPUT_TYPE_BASE64 = exports.InputSource = exports.UrlInput = exports.StreamInput = exports.PathInput = exports.BytesInput = exports.Base64Input = exports.PageOptionsOperation = void 0;
+var pageOptions_1 = require("./pageOptions");
+Object.defineProperty(exports, "PageOptionsOperation", { enumerable: true, get: function () { return pageOptions_1.PageOptionsOperation; } });
+var sources_1 = require("./sources");
+Object.defineProperty(exports, "Base64Input", { enumerable: true, get: function () { return sources_1.Base64Input; } });
+Object.defineProperty(exports, "BytesInput", { enumerable: true, get: function () { return sources_1.BytesInput; } });
+Object.defineProperty(exports, "PathInput", { enumerable: true, get: function () { return sources_1.PathInput; } });
+Object.defineProperty(exports, "StreamInput", { enumerable: true, get: function () { return sources_1.StreamInput; } });
+Object.defineProperty(exports, "UrlInput", { enumerable: true, get: function () { return sources_1.UrlInput; } });
+var base_1 = require("./base");
+Object.defineProperty(exports, "InputSource", { enumerable: true, get: function () { return base_1.InputSource; } });
+Object.defineProperty(exports, "INPUT_TYPE_BASE64", { enumerable: true, get: function () { return base_1.INPUT_TYPE_BASE64; } });
+Object.defineProperty(exports, "INPUT_TYPE_BYTES", { enumerable: true, get: function () { return base_1.INPUT_TYPE_BYTES; } });
+Object.defineProperty(exports, "INPUT_TYPE_PATH", { enumerable: true, get: function () { return base_1.INPUT_TYPE_PATH; } });
+Object.defineProperty(exports, "INPUT_TYPE_STREAM", { enumerable: true, get: function () { return base_1.INPUT_TYPE_STREAM; } });

package/src/inputs/pageOptions.d.ts

@@ -0,0 +1,20 @@
+export interface PageOptions {
+    /**
+     * Zero-based list of page indexes.
+     *
+     * A negative index can be used, indicating an offset from the end of the document.
+     *
+     * [0, -1] represents the fist and last pages of the document.
+     */
+    pageIndexes: number[];
+    /** Operation to apply on the document, given the `pageIndexes` specified. */
+    operation: PageOptionsOperation;
+    /**
+     * Apply the operation only if document has at least this many pages.
+     */
+    onMinPages: number;
+}
+export declare enum PageOptionsOperation {
+    KeepOnly = "KEEP_ONLY",
+    Remove = "REMOVE"
+}

package/src/inputs/pageOptions.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PageOptionsOperation = void 0;
+var PageOptionsOperation;
+(function (PageOptionsOperation) {
+    PageOptionsOperation["KeepOnly"] = "KEEP_ONLY";
+    PageOptionsOperation["Remove"] = "REMOVE";
+})(PageOptionsOperation = exports.PageOptionsOperation || (exports.PageOptionsOperation = {}));

package/src/inputs/sources.d.ts

@@ -0,0 +1,55 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { ReadStream } from "fs";
+import { Buffer } from "node:buffer";
+import { InputSource } from "./base";
+interface PathInputProps {
+    inputPath: string;
+}
+export declare class PathInput extends InputSource {
+    readonly inputPath: string;
+    fileObject: Buffer;
+    constructor({ inputPath }: PathInputProps);
+    init(): Promise<void>;
+}
+interface Base64InputProps {
+    inputString: string;
+    filename: string;
+}
+export declare class Base64Input extends InputSource {
+    private inputString;
+    fileObject: Buffer;
+    constructor({ inputString, filename }: Base64InputProps);
+    init(): Promise<void>;
+}
+interface StreamInputProps {
+    inputStream: ReadStream;
+    filename: string;
+}
+export declare class StreamInput extends InputSource {
+    private readonly inputStream;
+    fileObject: Buffer;
+    constructor({ inputStream, filename }: StreamInputProps);
+    init(): Promise<void>;
+    stream2buffer(stream: ReadStream): Promise<Buffer>;
+}
+interface BytesInputProps {
+    inputBytes: string;
+    filename: string;
+}
+export declare class BytesInput extends InputSource {
+    private inputBytes;
+    fileObject: Buffer;
+    constructor({ inputBytes, filename }: BytesInputProps);
+    init(): Promise<void>;
+}
+interface UrlInputProps {
+    url: string;
+}
+export declare class UrlInput extends InputSource {
+    private readonly url;
+    fileObject: string;
+    constructor({ url }: UrlInputProps);
+    init(): Promise<void>;
+}
+export {};

package/src/inputs/sources.js

@@ -0,0 +1,121 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UrlInput = exports.BytesInput = exports.StreamInput = exports.Base64Input = exports.PathInput = void 0;
+const fs_1 = require("fs");
+const path = __importStar(require("path"));
+const handler_1 = require("../errors/handler");
+const node_buffer_1 = require("node:buffer");
+const logger_1 = require("../logger");
+const base_1 = require("./base");
+class PathInput extends base_1.InputSource {
+    constructor({ inputPath }) {
+        super({
+            inputType: base_1.INPUT_TYPE_PATH,
+        });
+        this.fileObject = node_buffer_1.Buffer.alloc(0);
+        this.inputPath = inputPath;
+        this.filename = path.basename(this.inputPath);
+    }
+    async init() {
+        logger_1.logger.debug(`Loading from: ${this.inputPath}`);
+        this.fileObject = node_buffer_1.Buffer.from(await fs_1.promises.readFile(this.inputPath));
+        this.mimeType = await this.checkMimetype();
+    }
+}
+exports.PathInput = PathInput;
+class Base64Input extends base_1.InputSource {
+    constructor({ inputString, filename }) {
+        super({
+            inputType: base_1.INPUT_TYPE_BASE64,
+        });
+        this.fileObject = node_buffer_1.Buffer.alloc(0);
+        this.filename = filename;
+        this.inputString = inputString;
+    }
+    async init() {
+        this.fileObject = node_buffer_1.Buffer.from(this.inputString, "base64");
+        this.mimeType = await this.checkMimetype();
+        // clear out the string
+        this.inputString = "";
+    }
+}
+exports.Base64Input = Base64Input;
+class StreamInput extends base_1.InputSource {
+    constructor({ inputStream, filename }) {
+        super({
+            inputType: base_1.INPUT_TYPE_STREAM,
+        });
+        this.fileObject = node_buffer_1.Buffer.alloc(0);
+        this.filename = filename;
+        this.inputStream = inputStream;
+    }
+    async init() {
+        this.fileObject = await this.stream2buffer(this.inputStream);
+        this.mimeType = await this.checkMimetype();
+    }
+    async stream2buffer(stream) {
+        return new Promise((resolve, reject) => {
+            const _buf = Array();
+            stream.on("data", (chunk) => _buf.push(chunk));
+            stream.on("end", () => resolve(node_buffer_1.Buffer.concat(_buf)));
+            stream.on("error", (err) => reject(`Error converting stream - ${err}`));
+        });
+    }
+}
+exports.StreamInput = StreamInput;
+class BytesInput extends base_1.InputSource {
+    constructor({ inputBytes, filename }) {
+        super({
+            inputType: base_1.INPUT_TYPE_BYTES,
+        });
+        this.fileObject = node_buffer_1.Buffer.alloc(0);
+        this.filename = filename;
+        this.inputBytes = inputBytes;
+    }
+    async init() {
+        this.fileObject = node_buffer_1.Buffer.from(this.inputBytes, "hex");
+        this.mimeType = await this.checkMimetype();
+        // clear out the string
+        this.inputBytes = "";
+    }
+}
+exports.BytesInput = BytesInput;
+class UrlInput extends base_1.InputSource {
+    constructor({ url }) {
+        super({
+            inputType: base_1.INPUT_TYPE_URL,
+        });
+        this.url = url;
+    }
+    async init() {
+        if (!this.url.toLowerCase().startsWith("https")) {
+            handler_1.errorHandler.throw(new Error("URL must be HTTPS"));
+        }
+        this.fileObject = this.url;
+        this.filename = "hello.jpg";
+    }
+}
+exports.UrlInput = UrlInput;

package/src/pdf/index.d.ts

@@ -0,0 +1 @@
+export { extractPages, countPages, SplitPdf } from "./pdfOperation";

package/src/pdf/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.countPages = exports.extractPages = void 0;
+var pdfOperation_1 = require("./pdfOperation");
+Object.defineProperty(exports, "extractPages", { enumerable: true, get: function () { return pdfOperation_1.extractPages; } });
+Object.defineProperty(exports, "countPages", { enumerable: true, get: function () { return pdfOperation_1.countPages; } });

package/src/pdf/pdfOperation.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="node" />
+import { PageOptions } from "../inputs";
+export interface SplitPdf {
+    file: Buffer;
+    totalPagesRemoved: number;
+}
+/**
+ * Cut pages from a pdf file. If pages index are out of bound, it will throw an error.
+ * @param file
+ * @param pageOptions
+ * @returns the new cutted pdf file.
+ */
+export declare function extractPages(file: Buffer, pageOptions: PageOptions): Promise<SplitPdf>;
+export declare function countPages(file: Buffer): Promise<number>;