@campxdev/pdfme 1.1.0 → 1.2.1

package/dist/types/_vendors/pdf-lib/utils/elements/Arc.d.ts

@@ -0,0 +1,22 @@
+import Circle from './Circle';
+import GraphElement from './GraphElement';
+import Point from './Point';
+export default class Arc extends GraphElement {
+    O: Point;
+    A: Point;
+    B: Point;
+    /** Last sweep. Used to deduce the angle orientation */
+    lastSweep: number;
+    constructor(O?: Point, A?: Point, B?: Point, lastSweep?: number);
+    center(): Point;
+    origin(): Point;
+    destination(): Point;
+    sweep(): number;
+    ray(): number;
+    isEqual(element: GraphElement): boolean;
+    getCircle(): Circle;
+    originVect(): import("../..").Coordinates;
+    middle(): Point;
+    includes(P: Point): boolean;
+    orthoProjection(P: Point): Point;
+}

package/dist/types/_vendors/pdf-lib/utils/elements/Circle.d.ts

@@ -0,0 +1,14 @@
+import GraphElement from './GraphElement';
+import Point from './Point';
+export default class Circle extends GraphElement {
+    O: Point;
+    r: number;
+    constructor(O?: Point, r?: number);
+    ray(): number;
+    center(): Point;
+    /** This is used to standardize type Circle | Arc */
+    getCircle(): this;
+    isEqual(element: GraphElement): boolean;
+    includes(P: Point): boolean;
+    orthoProjection(P: Point): Point;
+}

package/dist/types/_vendors/pdf-lib/utils/elements/Ellipse.d.ts

@@ -0,0 +1,20 @@
+import { Size } from '../../types';
+import GraphElement from './GraphElement';
+import Point from './Point';
+import Segment from './Segment';
+export default class Ellipse extends GraphElement {
+    A: Point;
+    B: Point;
+    C: Point;
+    constructor(A?: Point, B?: Point, C?: Point);
+    center(): Point;
+    axis(): Segment;
+    a(): number;
+    b(): number;
+    rotation(): number;
+    getSize(): Size;
+    isEqual(element: GraphElement): boolean;
+    includes(P: Point): boolean;
+    orthoProjection(P: Point): Point;
+    polarRay(teta: number): number;
+}

package/dist/types/_vendors/pdf-lib/utils/elements/GraphElement.d.ts

@@ -0,0 +1,6 @@
+import Point from './Point';
+export default abstract class GraphElement {
+    abstract isEqual(element: GraphElement): boolean;
+    abstract orthoProjection(P: Point): Point;
+    distance(P: Point): number;
+}

package/dist/types/_vendors/pdf-lib/utils/elements/Line.d.ts

@@ -0,0 +1,23 @@
+import { Coordinates } from '../../types';
+import GraphElement from './GraphElement';
+import Point from './Point';
+export default class Line extends GraphElement {
+    origin(): Point;
+    dirVect(): Coordinates;
+    A: Point;
+    B: Point;
+    constructor(A?: Point, B?: Point);
+    /** Line equation */
+    y(x: number): number;
+    /** The slope */
+    a(): number;
+    /** Origin y coordinate */
+    b(): number;
+    isEqual(element: GraphElement): boolean;
+    /** Reversed line equation */
+    x(y: number): number;
+    includes(P: Point): boolean;
+    /** This is used to standarsize type Segment | HalfLine | Line */
+    getLine(): Line;
+    orthoProjection(P: Point): Point;
+}

package/dist/types/_vendors/pdf-lib/utils/elements/Plot.d.ts

@@ -0,0 +1,11 @@
+import { Coordinates } from '../../types';
+import GraphElement from './GraphElement';
+import Point from './Point';
+export default class Plot extends GraphElement {
+    points: Coordinates[];
+    constructor(points?: Coordinates[]);
+    getPoints(): Coordinates[];
+    translate(translationVector: Coordinates): void;
+    isEqual(element: GraphElement): boolean;
+    orthoProjection(P: Point): Point;
+}

package/dist/types/_vendors/pdf-lib/utils/elements/Point.d.ts

@@ -0,0 +1,18 @@
+import type { Coordinates } from '../../types';
+import GraphElement from './GraphElement';
+export default class Point extends GraphElement {
+    static type: string;
+    x: number;
+    y: number;
+    constructor(coords?: {
+        x: number;
+        y: number;
+    });
+    toCoords(): {
+        x: number;
+        y: number;
+    };
+    isEqual(element: GraphElement): boolean;
+    orthoProjection(): Point;
+    plus(vect: Coordinates): Point;
+}

package/dist/types/_vendors/pdf-lib/utils/elements/Rectangle.d.ts

@@ -0,0 +1,21 @@
+import GraphElement from './GraphElement';
+import Point from './Point';
+export default class Rectangle extends GraphElement {
+    static type: string;
+    start: Point;
+    end: Point;
+    constructor(start?: Point, end?: Point);
+    getSize(): {
+        width: number;
+        height: number;
+    };
+    getCoords(): {
+        x: number;
+        y: number;
+    };
+    getStart(): Point;
+    getEnd(): Point;
+    center(): Point;
+    isEqual(element: GraphElement): boolean;
+    orthoProjection(P: Point): Point;
+}

package/dist/types/_vendors/pdf-lib/utils/elements/Segment.d.ts

@@ -0,0 +1,19 @@
+import GraphElement from './GraphElement';
+import Line from './Line';
+import Point from './Point';
+export default class Segment extends GraphElement {
+    static type: string;
+    A: Point;
+    B: Point;
+    constructor(A?: Point, B?: Point);
+    origin(): Point;
+    destination(): Point;
+    dirVect(): import("../..").Coordinates;
+    length(): number;
+    isEqual(element: GraphElement): boolean;
+    /** Returns an equivalent line object */
+    getLine(): Line;
+    includes(P: Point): boolean;
+    middle(): Point;
+    orthoProjection(P: Point): Point;
+}

package/dist/types/_vendors/pdf-lib/utils/elements/index.d.ts

@@ -0,0 +1,9 @@
+export { default as Arc } from './Arc';
+export { default as Circle } from './Circle';
+export { default as GraphElement } from './GraphElement';
+export { default as Ellipse } from './Ellipse';
+export { default as Line } from './Line';
+export { default as SegmePlotnt } from './Plot';
+export { default as Point } from './Point';
+export { default as Rectangle } from './Rectangle';
+export { default as Segment } from './Segment';

package/dist/types/_vendors/pdf-lib/utils/errors.d.ts

@@ -0,0 +1 @@
+export declare const error: (msg: string) => never;

package/dist/types/_vendors/pdf-lib/utils/index.d.ts

@@ -0,0 +1,11 @@
+export * from './arrays';
+export * from './async';
+export * from './strings';
+export * from './unicode';
+export * from './numbers';
+export * from './errors';
+export * from './base64';
+export * from './objects';
+export * from './validators';
+export * from './pdfDocEncoding';
+export { default as Cache } from './Cache';

package/dist/types/_vendors/pdf-lib/utils/intersections.d.ts

@@ -0,0 +1,9 @@
+import Circle from './elements/Circle';
+import Line from './elements/Line';
+import { Coordinates, GraphicElement } from '../types';
+export declare function intersections(A: GraphicElement, B: GraphicElement): Coordinates[];
+export declare function intersection(A: GraphicElement, B: GraphicElement): Coordinates | undefined;
+export declare function intersectionLine(A: Line, B: Line): Coordinates[];
+export declare function intersectionCircleLine(A: Circle, B: Line): Coordinates[];
+export declare function intersectionCircle(A: Circle, B: Circle): Coordinates[];
+export declare function getIntersections(elements: GraphicElement[]): Coordinates[];

package/dist/types/_vendors/pdf-lib/utils/maths.d.ts

@@ -0,0 +1,45 @@
+import Point from './elements/Point';
+import { Coordinates } from '../types';
+/** This value represents the precision we accept for float values */
+export declare const FLOAT_APPROXIMATION = 0.000001;
+/** Calculates the distance between 2 points */
+export declare const distance: (A: Point, B: Point) => number;
+export declare const distanceCoords: (A: Coordinates, B: Coordinates) => number;
+/** Calculates the distance denoted by a vector */
+export declare const norm: (vect: Coordinates) => number;
+/** Calculates the orthogonal vector of provided vector */
+export declare const orthogonal: ({ x, y }: Coordinates) => Coordinates;
+/** Check if 2 vectors are proportional */
+export declare const isColinear: ({ x: ux, y: uy }: Coordinates, { x: vx, y: vy }: Coordinates) => boolean;
+/** Check if 2 floating values can be considered equals */
+export declare const isEqual: (a: number, b: number) => boolean;
+/** Return true if a is proportional to b: (a = kb), considering float imprecision */
+export declare const isProportional: (a: number, b: number) => boolean;
+/** Calculate the scalar product between 2 vectors */
+export declare const scalar: ({ x: ux, y: uy }: Coordinates, { x: vx, y: vy }: Coordinates) => number;
+/** Calculate the sum of 2 vectors */
+export declare const plus: ({ x: ux, y: uy }: Coordinates, { x: vx, y: vy }: Coordinates) => Coordinates;
+/** Calculate the vector multiplied by a scalar */
+export declare const times: ({ x, y }: Coordinates, k?: number) => Coordinates;
+/** Calculate the difference of 2 vectors */
+export declare const minus: (u: Coordinates, v: Coordinates) => Coordinates;
+/** Returns the vector between 2 points. */
+export declare const vector: (A: Point, B: Point) => Coordinates;
+/**
+ * Returns the angle between the vector and the horizontal axis (Ox).
+ * The return value is between -PI and PI.
+ * @returns {number} angle in radian between -Pi and Pi
+ */
+export declare const orientation: ({ x, y }: Coordinates) => number;
+/** Returns the unit vector associated to the provided vector,
+ * or the Null vector (0, 0) if the vector is null
+ */
+export declare const unitVector: (u: Coordinates) => Coordinates;
+/** Returns the angle from u to v in radian */
+export declare const angle: (u: Coordinates, v: Coordinates, previousAngle?: number) => number;
+/** Returns the angle between the lines (BA) and (BC) in radian
+ * @returns {number} the angle in radian, between -Pi and Pi
+ */
+export declare const angleABC: (A: Point, B: Point, C: Point, previousAngle?: number) => number;
+/** Rotate the vector by an angle in radian */
+export declare const rotate: (vect: Coordinates, teta: number) => Coordinates;

package/dist/types/_vendors/pdf-lib/utils/numbers.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Converts a number to its string representation in decimal. This function
+ * differs from simply converting a number to a string with `.toString()`
+ * because this function's output string will **not** contain exponential
+ * notation.
+ *
+ * Credit: https://stackoverflow.com/a/46545519
+ */
+export declare const numberToString: (num: number) => string;
+export declare const sizeInBytes: (n: number) => number;
+/**
+ * Converts a number into its constituent bytes and returns them as
+ * a number[].
+ *
+ * Returns most significant byte as first element in array. It may be necessary
+ * to call .reverse() to get the bits in the desired order.
+ *
+ * Example:
+ *   bytesFor(0x02A41E) => [ 0b10, 0b10100100, 0b11110 ]
+ *
+ * Credit for algorithm: https://stackoverflow.com/a/1936865
+ */
+export declare const bytesFor: (n: number) => Uint8Array<ArrayBuffer>;

package/dist/types/_vendors/pdf-lib/utils/objects.d.ts

@@ -0,0 +1,15 @@
+import { FontNames } from '@pdf-lib/standard-fonts';
+export declare const values: (obj: any) => any[];
+export declare const StandardFontValues: any[];
+export declare const isStandardFont: (input: any) => input is FontNames;
+export declare const rectanglesAreEqual: (a: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}, b: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}) => boolean;

package/dist/types/_vendors/pdf-lib/utils/pdfDocEncoding.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Decode a byte array into a string using PDFDocEncoding.
+ *
+ * @param bytes a byte array (decimal representation) containing a string
+ *              encoded with PDFDocEncoding.
+ */
+export declare const pdfDocEncodingDecode: (bytes: Uint8Array) => string;

package/dist/types/_vendors/pdf-lib/utils/png.d.ts

@@ -0,0 +1,17 @@
+export declare enum PngType {
+    Greyscale = "Greyscale",
+    Truecolour = "Truecolour",
+    IndexedColour = "IndexedColour",
+    GreyscaleWithAlpha = "GreyscaleWithAlpha",
+    TruecolourWithAlpha = "TruecolourWithAlpha"
+}
+export declare class PNG {
+    static load: (pngData: Uint8Array) => PNG;
+    readonly rgbChannel: Uint8Array;
+    readonly alphaChannel?: Uint8Array;
+    readonly type: PngType;
+    readonly width: number;
+    readonly height: number;
+    readonly bitsPerComponent: number;
+    private constructor();
+}

package/dist/types/_vendors/pdf-lib/utils/rng.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Generates a pseudo random number. Although it is not cryptographically secure
+ * and uniformly distributed, it is not a concern for the intended use-case,
+ * which is to generate distinct numbers.
+ *
+ * Credit: https://stackoverflow.com/a/19303725/10254049
+ */
+export declare class SimpleRNG {
+    static withSeed: (seed: number) => SimpleRNG;
+    private seed;
+    private constructor();
+    nextInt(): number;
+}

package/dist/types/_vendors/pdf-lib/utils/strings.d.ts

@@ -0,0 +1,25 @@
+export declare const toCharCode: (character: string) => number;
+export declare const toCodePoint: (character: string) => number | undefined;
+export declare const toHexStringOfMinLength: (num: number, minLength: number) => string;
+export declare const toHexString: (num: number) => string;
+export declare const charFromCode: (code: number) => string;
+export declare const charFromHexCode: (hex: string) => string;
+export declare const padStart: (value: string, length: number, padChar: string) => string;
+export declare const stringAsByteArray: (str: string) => Uint8Array;
+export declare const copyStringIntoBuffer: (str: string, buffer: Uint8Array, offset: number) => number;
+export declare const addRandomSuffix: (prefix: string, suffixLength?: number) => string;
+export declare const escapeRegExp: (str: string) => string;
+export declare const cleanText: (text: string) => string;
+export declare const escapedNewlineChars: string[];
+export declare const newlineChars: string[];
+export declare const isNewlineChar: (text: string) => boolean;
+export declare const lineSplit: (text: string) => string[];
+export declare const mergeLines: (text: string) => string;
+export declare const charAtIndex: (text: string, index: number) => [string, number];
+export declare const charSplit: (text: string) => string[];
+export declare const breakTextIntoLines: (text: string, wordBreaks: string[], maxWidth: number, computeWidthOfText: (t: string) => number) => string[];
+export declare const parseDate: (dateStr: string) => Date | undefined;
+export declare const findLastMatch: (value: string, regex: RegExp) => {
+    match: RegExpMatchArray | undefined;
+    pos: number;
+};

package/dist/types/_vendors/pdf-lib/utils/unicode.d.ts

@@ -0,0 +1,186 @@
+/**
+ * Encodes a string to UTF-8.
+ *
+ * @param input The string to be encoded.
+ * @param byteOrderMark Whether or not a byte order marker (BOM) should be added
+ *                      to the start of the encoding. (default `true`)
+ * @returns A Uint8Array containing the UTF-8 encoding of the input string.
+ *
+ * -----------------------------------------------------------------------------
+ *
+ * JavaScript strings are composed of Unicode code points. Code points are
+ * integers in the range 0 to 1,114,111 (0x10FFFF). When serializing a string,
+ * it must be encoded as a sequence of words. A word is typically 8, 16, or 32
+ * bytes in size. As such, Unicode defines three encoding forms: UTF-8, UTF-16,
+ * and UTF-32. These encoding forms are described in the Unicode standard [1].
+ * This function implements the UTF-8 encoding form.
+ *
+ * -----------------------------------------------------------------------------
+ *
+ * In UTF-8, each code point is mapped to a sequence of 1, 2, 3, or 4 bytes.
+ * Note that the logic which defines this mapping is slightly convoluted, and
+ * not as straightforward as the mapping logic for UTF-16 or UTF-32. The UTF-8
+ * mapping logic is as follows [2]:
+ *
+ * • If a code point is in the range U+0000..U+007F, then view it as a 7-bit
+ *   integer: 0bxxxxxxx. Map the code point to 1 byte with the first high order
+ *   bit set to 0:
+ *
+ *       b1=0b0xxxxxxx
+ *
+ * • If a code point is in the range U+0080..U+07FF, then view it as an 11-bit
+ *   integer: 0byyyyyxxxxxx. Map the code point to 2 bytes with the first 5 bits
+ *   of the code point stored in the first byte, and the last 6 bits stored in
+ *   the second byte:
+ *
+ *       b1=0b110yyyyy    b2=0b10xxxxxx
+ *
+ * • If a code point is in the range U+0800..U+FFFF, then view it as a 16-bit
+ *   integer, 0bzzzzyyyyyyxxxxxx. Map the code point to 3 bytes with the first
+ *   4 bits stored in the first byte, the next 6 bits stored in the second byte,
+ *   and the last 6 bits in the third byte:
+ *
+ *       b1=0b1110zzzz    b2=0b10yyyyyy    b3=0b10xxxxxx
+ *
+ * • If a code point is in the range U+10000...U+10FFFF, then view it as a
+ *   21-bit integer, 0bvvvzzzzzzyyyyyyxxxxxx. Map the code point to 4 bytes with
+ *   the first 3 bits stored in the first byte, the next 6 bits stored in the
+ *   second byte, the next 6 bits stored in the third byte, and the last 6 bits
+ *   stored in the fourth byte:
+ *
+ *       b1=0b11110xxx    b2=0b10zzzzzz    b3=0b10yyyyyy    b4=0b10xxxxxx
+ *
+ * -----------------------------------------------------------------------------
+ *
+ * It is important to note, when iterating through the code points of a string
+ * in JavaScript, that if a character is encoded as a surrogate pair it will
+ * increase the string's length by 2 instead of 1 [4]. For example:
+ *
+ * ```
+ * > 'a'.length
+ * 1
+ * > '💩'.length
+ * 2
+ * > '語'.length
+ * 1
+ * > 'a💩語'.length
+ * 4
+ * ```
+ *
+ * The results of the above example are explained by the fact that the
+ * characters 'a' and '語' are not represented by surrogate pairs, but '💩' is.
+ *
+ * Because of this idiosyncrasy in JavaScript's string implementation and APIs,
+ * we must "jump" an extra index after encoding a character as a surrogate
+ * pair. In practice, this means we must increment the index of our for loop by
+ * 2 if we encode a surrogate pair, and 1 in all other cases.
+ *
+ * -----------------------------------------------------------------------------
+ *
+ * References:
+ *   - [1] https://www.unicode.org/versions/Unicode12.0.0/UnicodeStandard-12.0.pdf
+ *         3.9  Unicode Encoding Forms - UTF-8
+ *   - [2] http://www.herongyang.com/Unicode/UTF-8-UTF-8-Encoding.html
+ *   - [3] http://www.herongyang.com/Unicode/UTF-8-UTF-8-Encoding-Algorithm.html
+ *   - [4] https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/length#Description
+ *
+ */
+export declare const utf8Encode: (input: string, byteOrderMark?: boolean) => Uint8Array;
+/**
+ * Encodes a string to UTF-16.
+ *
+ * @param input The string to be encoded.
+ * @param byteOrderMark Whether or not a byte order marker (BOM) should be added
+ *                      to the start of the encoding. (default `true`)
+ * @returns A Uint16Array containing the UTF-16 encoding of the input string.
+ *
+ * -----------------------------------------------------------------------------
+ *
+ * JavaScript strings are composed of Unicode code points. Code points are
+ * integers in the range 0 to 1,114,111 (0x10FFFF). When serializing a string,
+ * it must be encoded as a sequence of words. A word is typically 8, 16, or 32
+ * bytes in size. As such, Unicode defines three encoding forms: UTF-8, UTF-16,
+ * and UTF-32. These encoding forms are described in the Unicode standard [1].
+ * This function implements the UTF-16 encoding form.
+ *
+ * -----------------------------------------------------------------------------
+ *
+ * In UTF-16, each code point is mapped to one or two 16-bit integers. The
+ * UTF-16 mapping logic is as follows [2]:
+ *
+ * • If a code point is in the range U+0000..U+FFFF, then map the code point to
+ *   a 16-bit integer with the most significant byte first.
+ *
+ * • If a code point is in the range U+10000..U+10000, then map the code point
+ *   to two 16-bit integers. The first integer should contain the high surrogate
+ *   and the second integer should contain the low surrogate. Both surrogates
+ *   should be written with the most significant byte first.
+ *
+ * -----------------------------------------------------------------------------
+ *
+ * It is important to note, when iterating through the code points of a string
+ * in JavaScript, that if a character is encoded as a surrogate pair it will
+ * increase the string's length by 2 instead of 1 [4]. For example:
+ *
+ * ```
+ * > 'a'.length
+ * 1
+ * > '💩'.length
+ * 2
+ * > '語'.length
+ * 1
+ * > 'a💩語'.length
+ * 4
+ * ```
+ *
+ * The results of the above example are explained by the fact that the
+ * characters 'a' and '語' are not represented by surrogate pairs, but '💩' is.
+ *
+ * Because of this idiosyncrasy in JavaScript's string implementation and APIs,
+ * we must "jump" an extra index after encoding a character as a surrogate
+ * pair. In practice, this means we must increment the index of our for loop by
+ * 2 if we encode a surrogate pair, and 1 in all other cases.
+ *
+ * -----------------------------------------------------------------------------
+ *
+ * References:
+ *   - [1] https://www.unicode.org/versions/Unicode12.0.0/UnicodeStandard-12.0.pdf
+ *         3.9  Unicode Encoding Forms - UTF-8
+ *   - [2] http://www.herongyang.com/Unicode/UTF-16-UTF-16-Encoding.html
+ *   - [3] https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/length#Description
+ *
+ */
+export declare const utf16Encode: (input: string, byteOrderMark?: boolean) => Uint16Array;
+/**
+ * Returns `true` if the `codePoint` is within the
+ * Basic Multilingual Plane (BMP). Code points inside the BMP are not encoded
+ * with surrogate pairs.
+ * @param codePoint The code point to be evaluated.
+ *
+ * Reference: https://en.wikipedia.org/wiki/UTF-16#Description
+ */
+export declare const isWithinBMP: (codePoint: number) => boolean;
+/**
+ * Returns `true` if the given `codePoint` is valid and must be represented
+ * with a surrogate pair when encoded.
+ * @param codePoint The code point to be evaluated.
+ *
+ * Reference: https://en.wikipedia.org/wiki/UTF-16#Description
+ */
+export declare const hasSurrogates: (codePoint: number) => boolean;
+export declare const highSurrogate: (codePoint: number) => number;
+export declare const lowSurrogate: (codePoint: number) => number;
+/**
+ * Decodes a Uint8Array of data to a string using UTF-16.
+ *
+ * Note that this function attempts to recover from erronous input by
+ * inserting the replacement character (�) to mark invalid code points
+ * and surrogate pairs.
+ *
+ * @param input A Uint8Array containing UTF-16 encoded data
+ * @param byteOrderMark Whether or not a byte order marker (BOM) should be read
+ *                      at the start of the encoding. (default `true`)
+ * @returns The decoded string.
+ */
+export declare const utf16Decode: (input: Uint8Array, byteOrderMark?: boolean) => string;
+export declare const hasUtf16BOM: (bytes: Uint8Array) => boolean;

package/dist/types/_vendors/pdf-lib/utils/validators.d.ts

@@ -0,0 +1,26 @@
+export declare const backtick: (val: any) => string;
+export declare const singleQuote: (val: any) => string;
+type Primitive = string | number | boolean | undefined | null;
+export declare const createValueErrorMsg: (value: any, valueName: string, values: Primitive[]) => string;
+export declare const assertIsOneOf: (value: any, valueName: string, allowedValues: Primitive[] | {
+    [key: string]: Primitive;
+}) => void;
+export declare const assertIsOneOfOrUndefined: (value: any, valueName: string, allowedValues: Primitive[] | {
+    [key: string]: Primitive;
+}) => void;
+export declare const assertIsSubset: (values: any[], valueName: string, allowedValues: Primitive[] | {
+    [key: string]: Primitive;
+}) => void;
+export declare const getType: (val: any) => any;
+export type TypeDescriptor = 'null' | 'undefined' | 'string' | 'number' | 'boolean' | 'symbol' | 'bigint' | DateConstructor | ArrayConstructor | Uint8ArrayConstructor | ArrayBufferConstructor | FunctionConstructor | [Function, string];
+export declare const isType: (value: any, type: TypeDescriptor) => boolean;
+export declare const createTypeErrorMsg: (value: any, valueName: string, types: TypeDescriptor[]) => string;
+export declare const assertIs: (value: any, valueName: string, types: TypeDescriptor[]) => void;
+export declare const assertOrUndefined: (value: any, valueName: string, types: TypeDescriptor[]) => void;
+export declare const assertEachIs: (values: any[], valueName: string, types: TypeDescriptor[]) => void;
+export declare const assertRange: (value: any, valueName: string, min: number, max: number) => void;
+export declare const assertRangeOrUndefined: (value: any, valueName: string, min: number, max: number) => void;
+export declare const assertMultiple: (value: any, valueName: string, multiplier: number) => void;
+export declare const assertInteger: (value: any, valueName: string) => void;
+export declare const assertPositive: (value: number, valueName: string) => void;
+export {};

package/dist/types/_vendors/print-designer-editor/Canvas.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+export interface CanvasProps {
+    style?: React.CSSProperties;
+    className?: string;
+    /** Hide the built-in left sidebar (plugin icons). Default: false */
+    hideLeftSidebar?: boolean;
+    /** Hide the built-in right sidebar (prop panel). Default: false */
+    hideRightSidebar?: boolean;
+    /** Hide the built-in control bar (zoom/pager). Default: false */
+    hideCtlBar?: boolean;
+}
+export declare const Canvas: ({ style, className, hideLeftSidebar, hideRightSidebar, hideCtlBar, }: CanvasProps) => React.JSX.Element;

package/dist/types/_vendors/print-designer-editor/PdfmeProvider.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import type { PdfmeProviderProps, DesignerContextValue } from './types.js';
+export declare const DesignerContext: React.Context<DesignerContextValue | null>;
+export declare const PdfmeProvider: ({ template, plugins, options, children, }: PdfmeProviderProps) => React.JSX.Element;

package/dist/types/_vendors/print-designer-editor/PropPanel.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+export interface PropPanelProps {
+    style?: React.CSSProperties;
+    className?: string;
+}
+/**
+ * Standalone PropPanel that renders the property editor for the currently selected schema.
+ * Use this when you set `hideRightSidebar` on Canvas and want to place the panel elsewhere.
+ */
+export declare const PropPanel: ({ style, className }: PropPanelProps) => React.JSX.Element;

package/dist/types/_vendors/print-designer-editor/SchemaList.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+export interface SchemaListProps {
+    style?: React.CSSProperties;
+    className?: string;
+}
+/**
+ * Standalone SchemaList (plugin icon bar) for drag-and-drop schema creation.
+ * Use this when you set `hideLeftSidebar` on Canvas and want to place the list elsewhere.
+ */
+export declare const SchemaList: ({ style, className }: SchemaListProps) => React.JSX.Element;

package/dist/types/_vendors/print-designer-editor/index.d.ts

@@ -0,0 +1,14 @@
+export { PdfmeProvider } from './PdfmeProvider.js';
+export { Canvas } from './Canvas.js';
+export type { CanvasProps } from './Canvas.js';
+export { PropPanel } from './PropPanel.js';
+export type { PropPanelProps } from './PropPanel.js';
+export { SchemaList } from './SchemaList.js';
+export type { SchemaListProps } from './SchemaList.js';
+export { useDesigner } from './useDesigner.js';
+export { useDesignerContext } from './useDesignerContext.js';
+export { convertPdfToBase64 } from './utils.js';
+export { generate } from '../generator/index.js';
+export { getInputFromTemplate, getDefaultFont, getBuiltinFontsData, getAllFonts } from '../common/index.js';
+export { plugins } from './plugins.js';
+export type { Template, Schema, SchemaForUI, ChangeSchemas, Size, BasePdf, Font, Lang, UIOptions, Plugin, PluginRegistry, PdfmeProviderProps, DesignerContextValue, TemplateVariable, TemplateVariables, } from './types.js';

package/dist/types/_vendors/print-designer-editor/plugins.d.ts

@@ -0,0 +1 @@
+export declare const plugins: Record<string, any>;