scanbot-web-sdk 6.0.0-dev.1 → 6.0.0-dev.3

package/@types/core/bridge/compiled/PdfConfig.d.ts

@@ -0,0 +1,197 @@
+import { DeepPartial, PartiallyConstructible } from "../common";
+/**
+PDF attributes
+*/
+export declare class PdfAttributes extends PartiallyConstructible {
+    /**
+    Author
+    @defaultValue "Created with ❤️ with Scanbot SDK";
+    */
+    readonly author: string;
+    /**
+    Creator
+    @defaultValue "";
+    */
+    readonly creator: string;
+    /**
+    Title
+    @defaultValue "";
+    */
+    readonly title: string;
+    /**
+    Subject
+    @defaultValue "";
+    */
+    readonly subject: string;
+    /**
+    Keywords
+    @defaultValue "";
+    */
+    readonly keywords: string;
+    /** @param source {@displayType `DeepPartial<PdfAttributes>`} */
+    constructor(source?: DeepPartial<PdfAttributes>);
+}
+/**
+Page size
+
+- `LETTER`:
+   8.5 x 11 (inches)        612 x 792 (pixels) at 72 DPI
+- `LEGAL`:
+   8.5 x 14 (inches)        612 x 1008 (pixels) at 72 DPI
+- `A3`:
+   297 x 420 (mm)           841.89 x 1199.551 (pixels) at 72 DPI
+- `A4`:
+   210 x 297 (mm)           595.276 x 841.89 (pixels) at 72 DPI
+- `A5`:
+   148 x 210 (mm)           419.528 x 595.276 (pixels) at 72 DPI
+- `B4`:
+   250 x 353 (mm)           708.661 x 1000.63 (pixels) at 72 DPI
+- `B5`:
+   176 x 250 (mm)           498.898 x 708.661 (pixels) at 72 DPI
+- `EXECUTIVE`:
+   7.25 x 10.5 (inches)     522 x 756 (pixels) at 72 DPI
+- `US4x6`:
+   4 x 6 (inches)           288 x 432 (pixels) at 72 DPI
+- `US4x8`:
+   4 x 8 (inches)           288 x 576 (pixels) at 72 DPI
+- `US5x7`:
+   5 x 7 (inches)           360 x 504 (pixels) at 72 DPI
+- `COMM10`:
+   4.125 x 9.5 (inches)     297 x 684 (pixels) at 72 DPI
+- `CUSTOM`:
+   physical size will be calculated from the image dimensions and the `dpi` parameter.
+*/
+export type PageSize = "LETTER" | "LEGAL" | "A3" | "A4" | "A5" | "B4" | "B5" | "EXECUTIVE" | "US4x6" | "US4x8" | "US5x7" | "COMM10" | "CUSTOM";
+/**
+Page direction
+
+- `PORTRAIT`:
+   Portrait
+- `LANDSCAPE`:
+   Landscape
+- `AUTO`:
+   Decides based on image aspect ratio
+*/
+export type PageDirection = "PORTRAIT" | "LANDSCAPE" | "AUTO";
+/**
+Page fit
+
+- `FIT_IN`:
+   Fit image into page. May leave white borders if the aspect ratio
+   of the image and the page don't match. Preserves image aspect ratio.
+- `FILL_IN`:
+   Fill page with image. Will crop the image if the aspect ratio
+   of the image and the page don't match. Preserves image aspect ratio.
+- `STRETCH`:
+   Stretch image to fill the entire page. The image will never be cropped
+   and there will never be any white borders left, but the image aspect ratio
+   will be made to match the page aspect ratio.
+- `NONE`:
+   No resizing, centers the image on the page. The physical size of the image
+   will be determined by the `dpi` parameter.
+*/
+export type PageFit = "FIT_IN" | "FILL_IN" | "STRETCH" | "NONE";
+/**
+Resampling method
+
+- `NONE`:
+   Always geometrically rescale the image to fit the page if necessary. Fast.
+   
+   Otherwise, downscale the bitmap to match the `dpi` setting via the selected method before
+   adding it to the PDF if the calculated image DPI after stretching is greater than `dpi`.
+   Slower.
+- `NEAREST`:
+   Nearest-neighbor interpolation. Lowest quality. Produces blocky images, especially when
+   upsampling.
+- `LINEAR`:
+   Bi-linear interpolation. Better quality than nearest-neighbor, slower. Okay when the
+   target size is not too different from the source size.
+- `CUBIC`:
+   Bi-cubic interpolation. Better quality than bi-linear, slower. Produces high-quality
+   results in a larger range than that of bi-linear.
+- `LANCZOS4`:
+   Lanczos (Sinc) interpolation over 8x8 neighborhood. Produces very high quality results,
+   but slower than bi-cubic. Retains sharp edges like those of text when downsampling.
+- `AREA`:
+   Accurate, produces moire-free results, but tends to produce blurrier images. When
+   upsampling, it is similar to nearest-neighbor.
+*/
+export type ResamplingMethod = "NONE" | "NEAREST" | "LINEAR" | "CUBIC" | "LANCZOS4" | "AREA";
+/**
+The parameters `pageSize`, `pageFit`, `dpi` and `resamplingMethod` interact in a complex way
+when adding bitmap images (JPEG, PNG, or raw) to the PDF.
+There are three cases to consider:
+1. `pageSize` is `CUSTOM`:
+   in this case `dpi` is used as the conversion ratio to calculate both the physical page and
+   image sizes in inches from the bitmap dimensions. `resamplingMethod` is ignored.
+2. `pageSize` is not `CUSTOM` AND `pageFit` is `NONE`:
+   in this case `dpi` is used as the conversion ratio to calculate only the physical image
+   size in inches from the bitmap dimensions. The image is centered onto the page.
+   `resamplingMethod` is ignored.
+3. `pageSize` is not `CUSTOM` AND `pageFit` is not `NONE`:
+   in this case the page has a pre-determined physical size and we want to stretch the image to
+   fit the page in one of the ways described by `pageFit`. The image DPI is automatically
+   calculated for each image from the given physical page size, page fit setting and image
+   dimensions. There are two sub-cases to consider:
+   a. `resamplingMethod` is NONE OR the calculated DPI is less than or equal to `dpi`:
+      in this case the image is added to the PDF without resampling, which means that the image
+      rectangle is simply rescaled to fit into the page as specified by `pageFit` and
+      `pageSize`.
+   b. `resamplingMethod` is not NONE AND the calculated DPI is greater than `dpi`:
+      in this case the bitmap of the image is resampled to match `dpi` using the selected method
+      before adding it to the PDF. This will result in a bitmap that is smaller than the
+      original image and hence, the resulting PDF will be smaller in size.
+
+*/
+export declare class PdfConfig extends PartiallyConstructible {
+    /**
+    Attributes
+    @defaultValue new PdfAttributes({});
+    */
+    readonly attributes: PdfAttributes;
+    /**
+    Physical size of the page. If CUSTOM, the page size will be set as the image size at given dpi.
+    @defaultValue "A4";
+    */
+    readonly pageSize: PageSize;
+    /**
+    Page direction
+    @defaultValue "PORTRAIT";
+    */
+    readonly pageDirection: PageDirection;
+    /**
+    How to fit the image into the page. Only used if `pageSize` is not `CUSTOM`.
+    The image can either be stretched to fill the page,
+    in one of three ways, or centered on the page without stretching.
+    @defaultValue "FIT_IN";
+    */
+    readonly pageFit: PageFit;
+    /**
+    The `dpi` parameter has two different meanings depending on the value of `pageSize` and
+    `pageFit`. If pageSize is CUSTOM or pageFit is NONE, then `dpi` is the conversion ratio used
+    to convert from units of pixels to physical inches when adding bitmap images (JPEG, PNG, or
+    raw) to the PDF. Otherwise, if `resamplingMethod` is not NONE, then the image is downscaled
+    if necessary (if the image after being fit to the page has a higher calculated DPI than
+    `dpi`) to match `dpi` before adding it to the PDF. Otherwise, the setting is ignored and the
+    calculated image DPI is used instead.
+    @defaultValue 72;
+    */
+    readonly dpi: number;
+    /**
+    JPEG quality for images.
+    Applies if an image is added as a cv::Mat and therefore needs to be encoded.
+    Also applies if `resamplingMethod` not NONE and the image being added needs to be
+    downscaled. Otherwise, when adding JPEG files to the PDF, the files are copied directly into
+    the PDF and not re-encoded, which is many times faster and also preserves the quality of the
+    original.
+    @defaultValue 80;
+    */
+    readonly jpegQuality: number;
+    /**
+    Resampling method
+    @defaultValue "NONE";
+    */
+    readonly resamplingMethod: ResamplingMethod;
+    /** @param source {@displayType `DeepPartial<PdfConfig>`} */
+    constructor(source?: DeepPartial<PdfConfig>);
+}

package/@types/core/bridge/compiled/TiffTypes.d.ts

@@ -0,0 +1,183 @@
+import { DeepPartial, PartiallyConstructible } from "../common";
+import { ParametricFilter } from "./ParametricFilters";
+/**
+TIFF compression type
+
+- `NONE`:
+   dump mode
+- `CCITTRLE`:
+   CCITT modified Huffman RLE
+- `CCITTFAX3`:
+   CCITT Group 3 fax encoding
+- `CCITT_T4`:
+   CCITT T.4 (TIFF 6 name)
+- `CCITTFAX4`:
+   CCITT Group 4 fax encoding
+- `CCITT_T6`:
+   CCITT T.6 (TIFF 6 name)
+- `LZW`:
+   Lempel-Ziv & Welch
+- `OJPEG`:
+   !6.0 JPEG
+- `JPEG`:
+   %JPEG DCT compression
+- `T85`:
+   !TIFF/FX T.85 JBIG compression
+- `T43`:
+   !TIFF/FX T.43 colour by layered JBIG compression
+- `NEXT`:
+   NeXT 2-bit RLE
+- `CCITTRLEW`:
+   #1 w/ word alignment
+- `PACKBITS`:
+   Macintosh RLE
+- `THUNDERSCAN`:
+   ThunderScan RLE
+- `IT8CTPAD`:
+   IT8 CT w/padding
+- `IT8LW`:
+   IT8 Linework RLE
+- `IT8MP`:
+   IT8 Monochrome picture
+- `IT8BL`:
+   IT8 Binary line art
+- `PIXARFILM`:
+   Pixar companded 10bit LZW
+- `PIXARLOG`:
+   Pixar companded 11bit ZIP
+- `DEFLATE`:
+   Deflate compression
+- `ADOBE_DEFLATE`:
+   Deflate compression, as recognized by Adobe
+*/
+export type CompressionMode = "NONE" | "CCITTRLE" | "CCITTFAX3" | "CCITT_T4" | "CCITTFAX4" | "CCITT_T6" | "LZW" | "OJPEG" | "JPEG" | "T85" | "T43" | "NEXT" | "CCITTRLEW" | "PACKBITS" | "THUNDERSCAN" | "IT8CTPAD" | "IT8LW" | "IT8MP" | "IT8BL" | "PIXARFILM" | "PIXARLOG" | "DEFLATE" | "ADOBE_DEFLATE";
+/**
+Binarization behavior to apply when adding pages to a TIFF
+
+- `NO`:
+   Do not binarize the image. Image will be stored as a grayscale or color TIFF.
+- `YES`:
+   Binarize the image. Image will be stored as a 1-bit TIFF. If the input image is not black-and-white, a simple thresholding is applied.
+- `IF_BINARIZATION_FILTER_SET`:
+   Binarize the image (same behavior as YES) if a binarization filter (TIFFWriterParameters.binarizationFilter) is set. This is the default.
+*/
+export type Binarize = "NO" | "YES" | "IF_BINARIZATION_FILTER_SET";
+/**
+User-defined TIFF field value
+*/
+export type UserFieldValue = UserFieldDoubleValue | UserFieldStringValue | UserFieldIntValue;
+/** @internal */
+export declare namespace UserFieldValue {
+    /** @internal */
+    function From(source: {
+        [key: string]: any;
+    }): UserFieldValue;
+}
+/**
+Double value (TIFF_DOUBLE)
+*/
+export declare class UserFieldDoubleValue extends PartiallyConstructible {
+    readonly _type: "UserFieldDoubleValue";
+    /**
+    Value
+    */
+    readonly value: number;
+    /** @param source {@displayType `DeepPartial<UserFieldDoubleValue>`} */
+    constructor(source?: DeepPartial<UserFieldDoubleValue>);
+}
+/**
+ASCII string value (TIFF_ASCII)
+*/
+export declare class UserFieldStringValue extends PartiallyConstructible {
+    readonly _type: "UserFieldStringValue";
+    /**
+    Value
+    */
+    readonly value: string;
+    /** @param source {@displayType `DeepPartial<UserFieldStringValue>`} */
+    constructor(source?: DeepPartial<UserFieldStringValue>);
+}
+/**
+32-bit int value (TIFF_LONG)
+*/
+export declare class UserFieldIntValue extends PartiallyConstructible {
+    readonly _type: "UserFieldIntValue";
+    /**
+    Value
+    */
+    readonly value: number;
+    /** @param source {@displayType `DeepPartial<UserFieldIntValue>`} */
+    constructor(source?: DeepPartial<UserFieldIntValue>);
+}
+/**
+User-defined TIFF field
+*/
+export declare class UserField extends PartiallyConstructible {
+    /**
+    Numeric tag
+    */
+    readonly tag: number;
+    /**
+    Field name
+    */
+    readonly name: string;
+    /**
+    Value
+    */
+    readonly value: UserFieldValue;
+    /** @param source {@displayType `DeepPartial<UserField>`} */
+    constructor(source?: DeepPartial<UserField>);
+}
+/**
+TIFF writer parameters
+*/
+export declare class TIFFWriterParameters extends PartiallyConstructible {
+    /**
+    Compression
+    @defaultValue "LZW";
+    */
+    compression: CompressionMode;
+    /**
+    JPEG quality (TIFFTAG_JPEGQUALITY). Values range from 0 to 100.
+    @defaultValue 80;
+    */
+    jpegQuality: number;
+    /**
+    ZIP/Deflate compression level (TIFFTAG_ZIPQUALITY). Values range from 1 to 9.
+    @defaultValue 6;
+    */
+    zipCompressionLevel: number;
+    /**
+    DPI value
+    @defaultValue 72;
+    */
+    dpi: number;
+    /**
+    User-defined fields
+    @defaultValue [];
+    */
+    userFields: UserField[];
+    /**
+    Filter to apply to the input image when adding pages with binarization.
+    If set, the filter is applied to the input image and the resulting image is stored as a 1-bit TIFF.
+    When storing documents it's typically best to use the BINARY_DOCUMENT_OPTIMIZED_COMPRESSION compression mode (CCITTFAX4)
+    instead of the default, as it tends to produce the smallest file sizes.
+    If not set, simple thresholding is applied to the image, instead.
+    @defaultValue null;
+    */
+    binarizationFilter: ParametricFilter | null;
+    /** @param source {@displayType `DeepPartial<TIFFWriterParameters>`} */
+    constructor(source?: DeepPartial<TIFFWriterParameters>);
+}
+export declare namespace TIFFWriterParameters {
+    /**
+    Default compression
+    @defaultValue "LZW";
+    */
+    const defaultCompression: CompressionMode;
+    /**
+    Compression mode typically producing the smallest file sizes for binary (1-bit) document images
+    @defaultValue "CCITTFAX4";
+    */
+    const binaryDocumentOptimizedCompression: CompressionMode;
+}

package/@types/core/bridge/utils.d.ts

@@ -0,0 +1,7 @@
+export declare function gatherTransferables(args: any, useCopy?: boolean): Transferable[];
+export declare function isRemote(path: string): boolean;
+export declare function areThreadsAvailable(): boolean;
+export declare function getBuildType(options: {
+    allowSimd?: boolean;
+    allowThreads?: boolean;
+}): string;