@adnsistemas/pdf-lib 2.8.1 → 2.9.1

package/src/utils/elements/Ellipse.ts

@@ -1,3 +1,4 @@
+import { isPDFInstance, PDFClasses } from '../../api/objects';
 import { Size } from '../../types';
 import {
   angle,
@@ -15,6 +16,10 @@ import Point from './Point';
 import Segment from './Segment';
 
 export default class Ellipse extends GraphElement {
+  static className = () => PDFClasses.Ellipse;
+  myClass(): PDFClasses {
+    return PDFClasses.Ellipse;
+  }
   A: Point;
   B: Point;
   C: Point;
@@ -62,13 +67,13 @@ export default class Ellipse extends GraphElement {
   }
 
   isEqual(element: GraphElement): boolean {
-    if (!(element instanceof Ellipse)) return false;
+    if (!isPDFInstance(element, PDFClasses.Ellipse)) return false;
     const a = this.a();
     const b = this.b();
     const rotation = this.rotation();
-    const eltA = element.a();
-    const eltB = element.b();
-    const eltRotation = element.rotation();
+    const eltA = (element as Ellipse).a();
+    const eltB = (element as Ellipse).b();
+    const eltRotation = (element as Ellipse).rotation();
     // If the main axis is the same on both ellipse
     if (eltA < eltB === a < b) {
       // The rotation is equivalent module PI as the element is symetrical

package/src/utils/elements/GraphElement.ts

@@ -1,8 +1,11 @@
+import { PDFClasses } from '../../api/objects';
 import { distance } from '../maths';
 
 import Point from './Point';
 
 export default abstract class GraphElement {
+  abstract myClass(): PDFClasses;
+
   abstract isEqual(element: GraphElement): boolean;
 
   abstract orthoProjection(P: Point): Point;

package/src/utils/elements/Line.ts

@@ -1,3 +1,4 @@
+import { isPDFInstance, PDFClasses } from '../../api/objects';
 import { Coordinates } from '../../types';
 import { intersectionLine } from '../intersections';
 import { isColinear, isEqual, orthogonal, vector } from '../maths';
@@ -6,6 +7,10 @@ import GraphElement from './GraphElement';
 import Point from './Point';
 
 export default class Line extends GraphElement {
+  static className = () => PDFClasses.Line;
+  myClass(): PDFClasses {
+    return PDFClasses.Line;
+  }
   origin(): Point {
     return this.A;
   }
@@ -46,12 +51,15 @@ export default class Line extends GraphElement {
   isEqual(element: GraphElement): boolean {
     const vect = this.dirVect();
     return (
-      element instanceof Line &&
-      isColinear(vect, element.dirVect()) &&
+      isPDFInstance(element, PDFClasses.Line) &&
+      isColinear(vect, (element as Line).dirVect()) &&
       (isEqual(vect.x, 0)
         ? // We need to take care of the case of the vertical line
-          isEqual(this.origin().toCoords().x, element.origin().toCoords().x)
-        : isEqual(this.b(), element.b()))
+          isEqual(
+            this.origin().toCoords().x,
+            (element as Line).origin().toCoords().x,
+          )
+        : isEqual(this.b(), (element as Line).b()))
     );
   }
 

package/src/utils/elements/Plot.ts

@@ -1,3 +1,4 @@
+import { isPDFInstance, PDFClasses } from '../../api/objects';
 import { Coordinates } from '../../types';
 import { plus } from '../maths';
 
@@ -5,6 +6,10 @@ import GraphElement from './GraphElement';
 import Point from './Point';
 import Segment from './Segment';
 export default class Plot extends GraphElement {
+  static className = () => PDFClasses.Plot;
+  myClass(): PDFClasses {
+    return PDFClasses.Plot;
+  }
   points: Coordinates[];
 
   constructor(points: Coordinates[] = []) {
@@ -21,9 +26,11 @@ export default class Plot extends GraphElement {
   }
 
   isEqual(element: GraphElement): boolean {
-    if (!(element instanceof Plot)) return false;
+    if (!isPDFInstance(element, PDFClasses.Plot)) return false;
     const points = this.getPoints().map((coord) => new Point(coord));
-    const points2 = element.getPoints().map((coord) => new Point(coord));
+    const points2 = (element as Plot)
+      .getPoints()
+      .map((coord) => new Point(coord));
     return (
       points.every((point, i) => point.isEqual(points2[i])) ||
       points.reverse().every((point, i) => point.isEqual(points2[i]))

package/src/utils/elements/Point.ts

@@ -1,9 +1,14 @@
+import { isPDFInstance, PDFClasses } from '../../api/objects';
 import type { Coordinates } from '../../types';
 
 import { isEqual, plus } from '../maths';
 import GraphElement from './GraphElement';
 
 export default class Point extends GraphElement {
+  static className = () => PDFClasses.Point;
+  myClass(): PDFClasses {
+    return PDFClasses.Point;
+  }
   static type = 'PointFixed';
 
   x: number;
@@ -20,9 +25,9 @@ export default class Point extends GraphElement {
   }
 
   isEqual(element: GraphElement): boolean {
-    if (!(element instanceof Point)) return false;
+    if (!isPDFInstance(element, PDFClasses.Point)) return false;
     const A = this.toCoords();
-    const B = element.toCoords();
+    const B = (element as Point).toCoords();
     return isEqual(A.x, B.x) && isEqual(A.y, B.y);
   }
 

package/src/utils/elements/Rectangle.ts

@@ -1,8 +1,13 @@
+import { isPDFInstance, PDFClasses } from '../../api/objects';
 import GraphElement from './GraphElement';
 import Point from './Point';
 import Segment from './Segment';
 
 export default class Rectangle extends GraphElement {
+  static className = () => PDFClasses.Rectangle;
+  myClass(): PDFClasses {
+    return PDFClasses.Rectangle;
+  }
   static type = 'Rectangle';
   start: Point;
   end: Point;
@@ -48,9 +53,9 @@ export default class Rectangle extends GraphElement {
 
   isEqual(element: GraphElement): boolean {
     return (
-      element instanceof Rectangle &&
-      this.getStart().isEqual(element.getStart()) &&
-      this.getEnd().isEqual(element.getEnd())
+      isPDFInstance(element, PDFClasses.Rectangle) &&
+      this.getStart().isEqual((element as Rectangle).getStart()) &&
+      this.getEnd().isEqual((element as Rectangle).getEnd())
     );
   }
 

package/src/utils/elements/Segment.ts

@@ -1,3 +1,4 @@
+import { isPDFInstance, PDFClasses } from '../../api/objects';
 import {
   distance,
   isColinear,
@@ -13,6 +14,10 @@ import Line from './Line';
 import Point from './Point';
 
 export default class Segment extends GraphElement {
+  static className = () => PDFClasses.Segment;
+  myClass(): PDFClasses {
+    return PDFClasses.Segment;
+  }
   static type = 'Segment';
   A: Point;
   B: Point;
@@ -39,15 +44,14 @@ export default class Segment extends GraphElement {
   }
 
   isEqual(element: GraphElement): boolean {
-    if (!(element instanceof Segment)) return false;
+    if (!isPDFInstance(element, PDFClasses.Segment)) return false;
     const o = this.origin();
     const dest = this.destination();
-    const oE = element.origin();
-    const destE = element.destination();
+    const oE = (element as Segment).origin();
+    const destE = (element as Segment).destination();
     return (
-      element instanceof Segment &&
-      ((o.isEqual(oE) && dest.isEqual(destE)) ||
-        (o.isEqual(destE) && dest.isEqual(oE)))
+      (o.isEqual(oE) && dest.isEqual(destE)) ||
+      (o.isEqual(destE) && dest.isEqual(oE))
     );
   }
 

package/src/utils/intersections.ts

@@ -18,29 +18,47 @@ import {
   vector,
   rotate,
 } from './maths';
+import { isPDFInstance, PDFClasses } from '../api/objects';
 
 export const intersections = (
   A: GraphicElement,
   B: GraphicElement,
 ): Coordinates[] => {
-  if (A instanceof Point || B instanceof Point) return [];
+  if (isPDFInstance(A, PDFClasses.Point) || isPDFInstance(B, PDFClasses.Point))
+    return [];
   else if (A instanceof Text || B instanceof Text) return [];
   else if (A instanceof Image || B instanceof Image) return [];
   // TODO: calculate the coords of the intersection: https://www.emathzone.com/tutorials/geometry/intersection-of-line-and-ellipse.html
-  else if (A instanceof Line) return intersectionsLine(A, B);
-  else if (A instanceof Segment) {
-    return intersectionsLine(A.getLine(), B).filter((P) =>
-      A.includes(new Point(P)),
+  else if (isPDFInstance(A, PDFClasses.Line))
+    return intersectionsLine(
+      A as Line,
+      B as Arc | Circle | Ellipse | Line | Plot | Rectangle | Segment,
     );
-  } else if (A instanceof Circle) return intersectionsCircle(A, B);
-  else if (A instanceof Arc) {
-    return intersectionsCircle(A.getCircle(), B).filter((P) =>
-      A.includes(new Point(P)),
+  else if (isPDFInstance(A, PDFClasses.Segment)) {
+    return intersectionsLine(
+      (A as Segment).getLine(),
+      B as Arc | Circle | Ellipse | Line | Plot | Rectangle | Segment,
+    ).filter((P) => (A as Segment).includes(new Point(P)));
+  } else if (isPDFInstance(A, PDFClasses.Circle))
+    return intersectionsCircle(
+      A as Circle,
+      B as Arc | Circle | Ellipse | Line | Plot | Rectangle | Segment,
     );
-  } else if (A instanceof Plot) return intersectionsPlot(A, B);
-  else if (A instanceof Rectangle) return intersectionsRectangle(A, B);
-  else if (A instanceof Ellipse) return intersectionsEllipse(A, B);
-  return A;
+  else if (isPDFInstance(A, PDFClasses.Arc)) {
+    return intersectionsCircle(
+      (A as Arc).getCircle(),
+      B as Arc | Circle | Ellipse | Line | Plot | Rectangle | Segment,
+    ).filter((P) => (A as Arc).includes(new Point(P)));
+  } else if (isPDFInstance(A, PDFClasses.Plot))
+    return intersectionsPlot(A as Plot, B);
+  else if (isPDFInstance(A, PDFClasses.Rectangle))
+    return intersectionsRectangle(A as Rectangle, B);
+  else if (isPDFInstance(A, PDFClasses.Ellipse))
+    return intersectionsEllipse(
+      A as Ellipse,
+      B as Arc | Circle | Ellipse | Line | Plot | Rectangle | Segment,
+    );
+  return A as never;
 };
 
 export const intersection = (
@@ -52,45 +70,52 @@ const intersectionsLine = (
   A: Line,
   B: Exclude<GraphicElement, Text | Point>,
 ): Coordinates[] => {
-  if (B instanceof Line) return intersectionLine(A, B);
-  else if (B instanceof Segment) {
-    return intersectionLine(A, B.getLine()).filter((P) =>
-      B.includes(new Point(P)),
+  if (isPDFInstance(B, PDFClasses.Line)) return intersectionLine(A, B as Line);
+  else if (isPDFInstance(B, PDFClasses.Segment)) {
+    return intersectionLine(A, (B as Segment).getLine()).filter((P) =>
+      (B as Segment).includes(new Point(P)),
     );
-  } else if (B instanceof Circle) return intersectionCircleLine(B, A);
-  else if (B instanceof Arc) {
-    return intersectionsCircle(B.getCircle(), A).filter((P) =>
-      B.includes(new Point(P)),
+  } else if (isPDFInstance(B, PDFClasses.Circle))
+    return intersectionCircleLine(B as Circle, A);
+  else if (isPDFInstance(B, PDFClasses.Arc)) {
+    return intersectionsCircle((B as Arc).getCircle(), A).filter((P) =>
+      (B as Arc).includes(new Point(P)),
     );
-  } else if (B instanceof Plot) return intersectionsPlot(B, A);
-  else if (B instanceof Rectangle) return intersectionsRectangle(B, A);
-  else if (B instanceof Ellipse) return intersectionsEllipse(B, A);
-  return B;
+  } else if (isPDFInstance(B, PDFClasses.Plot))
+    return intersectionsPlot(B as Plot, A);
+  else if (isPDFInstance(B, PDFClasses.Rectangle))
+    return intersectionsRectangle(B as Rectangle, A);
+  else if (isPDFInstance(B, PDFClasses.Ellipse))
+    return intersectionsEllipse(B as Ellipse, A);
+  return B as never;
 };
 
 const intersectionsEllipse = (
   A: Ellipse,
   B: Exclude<GraphicElement, Text | Point>,
 ): Coordinates[] => {
-  if (B instanceof Line) return intersectionsLineAndEllipse(A, B);
-  else if (B instanceof Segment) {
-    return intersectionsEllipse(A, B.getLine()).filter((P) =>
-      B.includes(new Point(P)),
+  if (isPDFInstance(B, PDFClasses.Line))
+    return intersectionsLineAndEllipse(A, B as Line);
+  else if (isPDFInstance(B, PDFClasses.Segment)) {
+    return intersectionsEllipse(A, (B as Segment).getLine()).filter((P) =>
+      (B as Segment).includes(new Point(P)),
     );
   }
   // TODO:
-  // else if (B instanceof Circle) return intersectionEllipseCircle(B, A)
-  else if (B instanceof Circle) return [];
+  // else if (isPDFInstnace(B, PDFClasses.Circle)) return intersectionEllipseCircle(B as Circle, A);
+  else if (isPDFInstance(B, PDFClasses.Circle)) return [];
   // TODO:
-  // else if (B instanceof Ellipse) return intersectionEllipseEllipse(B, A)
-  else if (B instanceof Ellipse) return [];
-  else if (B instanceof Arc) {
-    return intersectionsEllipse(A, B.getCircle()).filter((P) =>
-      B.includes(new Point(P)),
+  // else if (isPDFInstance(B, PDFClasses.Ellipse)) return intersectionEllipseEllipse(B as Ellipse, A);
+  else if (isPDFInstance(B, PDFClasses.Ellipse)) return [];
+  else if (isPDFInstance(B, PDFClasses.Arc)) {
+    return intersectionsEllipse(A, (B as Arc).getCircle()).filter((P) =>
+      (B as Arc).includes(new Point(P)),
     );
-  } else if (B instanceof Plot) return intersectionsPlot(B, A);
-  else if (B instanceof Rectangle) return intersectionsRectangle(B, A);
-  return B;
+  } else if (isPDFInstance(B, PDFClasses.Plot))
+    return intersectionsPlot(B as Plot, A);
+  else if (isPDFInstance(B, PDFClasses.Rectangle))
+    return intersectionsRectangle(B as Rectangle, A);
+  return B as never;
 };
 
 const intersectionsLineAndEllipse = (A: Ellipse, B: Line): Coordinates[] => {
@@ -253,20 +278,25 @@ const intersectionsCircle = (
   A: Circle,
   B: Exclude<GraphicElement, Text | Point>,
 ): Coordinates[] => {
-  if (B instanceof Circle) return intersectionCircle(A, B);
-  else if (B instanceof Line) return intersectionCircleLine(A, B);
-  else if (B instanceof Segment) {
-    return intersectionCircleLine(A, B.getLine()).filter((P) =>
-      B.includes(new Point(P)),
+  if (isPDFInstance(B, PDFClasses.Circle))
+    return intersectionCircle(A, B as Circle);
+  else if (isPDFInstance(B, PDFClasses.Line))
+    return intersectionCircleLine(A, B as Line);
+  else if (isPDFInstance(B, PDFClasses.Segment)) {
+    return intersectionCircleLine(A, (B as Segment).getLine()).filter((P) =>
+      (B as Segment).includes(new Point(P)),
     );
-  } else if (B instanceof Arc) {
-    return intersectionCircle(A, B.getCircle()).filter((P) =>
-      B.includes(new Point(P)),
+  } else if (isPDFInstance(B, PDFClasses.Arc)) {
+    return intersectionCircle(A, (B as Arc).getCircle()).filter((P) =>
+      (B as Arc).includes(new Point(P)),
     );
-  } else if (B instanceof Plot) return intersectionsPlot(B, A);
-  else if (B instanceof Rectangle) return intersectionsRectangle(B, A);
-  else if (B instanceof Ellipse) return intersectionsEllipse(B, A);
-  return B;
+  } else if (isPDFInstance(B, PDFClasses.Plot))
+    return intersectionsPlot(B as Plot, A);
+  else if (isPDFInstance(B, PDFClasses.Rectangle))
+    return intersectionsRectangle(B as Rectangle, A);
+  else if (isPDFInstance(B, PDFClasses.Ellipse))
+    return intersectionsEllipse(B as Ellipse, A);
+  return B as never;
 };
 
 export const getIntersections = (elements: GraphicElement[]) => {

package/ts3.4/cjs/api/PDFDocument.d.ts

@@ -15,6 +15,7 @@ import PDFEmbeddedFile from './PDFEmbeddedFile';
 import PDFSvg from './PDFSvg';
 import { SecurityOptions } from '../core/security/PDFSecurity';
 import { DocumentSnapshot } from './snapshot';
+import { PDFClasses } from './objects';
 export type BasePDFAttachment = {
     name: string;
     data: Uint8Array;
@@ -99,6 +100,8 @@ export default class PDFDocument {
      * @returns Resolves with the newly created document.
      */
     static create(options?: CreateOptions): Promise<PDFDocument>;
+    static className: () => PDFClasses;
+    myClass(): PDFClasses;
     /** The low-level context of this document. */
     readonly context: PDFContext;
     /** The catalog of this document. */

package/ts3.4/cjs/api/form/PDFButton.d.ts

@@ -6,6 +6,7 @@ import { ImageAlignment } from '../image/alignment';
 import { AppearanceProviderFor } from './appearances';
 import PDFField, { FieldAppearanceOptions } from './PDFField';
 import { PDFRef, PDFAcroPushButton } from '../../core';
+import { PDFClasses } from '../objects';
 /**
  * Represents a button field of a [[PDFForm]].
  *
@@ -16,6 +17,8 @@ import { PDFRef, PDFAcroPushButton } from '../../core';
  * have a text label describing the action that they perform when clicked.
  */
 export default class PDFButton extends PDFField {
+    static className: () => PDFClasses;
+    myClass(): PDFClasses;
     /**
      * > **NOTE:** You probably don't want to call this method directly. Instead,
      * > consider using the [[PDFForm.getButton]] method, which will create an

package/ts3.4/cjs/api/form/PDFCheckBox.d.ts

@@ -3,6 +3,7 @@ import PDFPage from '../PDFPage';
 import { AppearanceProviderFor } from './appearances';
 import PDFField, { FieldAppearanceOptions } from './PDFField';
 import { PDFRef, PDFAcroCheckBox } from '../../core';
+import { PDFClasses } from '../objects';
 /**
  * Represents a check box field of a [[PDFForm]].
  *
@@ -13,6 +14,8 @@ import { PDFRef, PDFAcroCheckBox } from '../../core';
  * square in shape and display a check mark when they are in the `on` state.
  */
 export default class PDFCheckBox extends PDFField {
+    static className: () => PDFClasses;
+    myClass(): PDFClasses;
     /**
      * > **NOTE:** You probably don't want to call this method directly. Instead,
      * > consider using the [[PDFForm.getCheckBox]] method, which will create an

package/ts3.4/cjs/api/form/PDFDropdown.d.ts

@@ -4,6 +4,7 @@ import PDFFont from '../PDFFont';
 import PDFField, { FieldAppearanceOptions } from './PDFField';
 import { AppearanceProviderFor } from './appearances';
 import { PDFRef, PDFAcroComboBox } from '../../core';
+import { PDFClasses } from '../objects';
 /**
  * Represents a dropdown field of a [[PDFForm]].
  *
@@ -17,6 +18,8 @@ import { PDFRef, PDFAcroComboBox } from '../../core';
  * choose an option from the list (see [[PDFDropdown.isEditable]]).
  */
 export default class PDFDropdown extends PDFField {
+    static className: () => PDFClasses;
+    myClass(): PDFClasses;
     /**
      * > **NOTE:** You probably don't want to call this method directly. Instead,
      * > consider using the [[PDFForm.getDropdown]] method, which will create an

package/ts3.4/cjs/api/form/PDFField.d.ts

@@ -6,6 +6,7 @@ import { Rotation } from '../rotations';
 import { PDFRef, PDFWidgetAnnotation, PDFOperator, PDFName, PDFDict, PDFAcroTerminal } from '../../core';
 import { ImageAlignment } from '../image';
 import PDFImage from '../PDFImage';
+import { PDFClasses } from '../objects';
 export interface FieldAppearanceOptions {
     x?: number;
     y?: number;
@@ -41,6 +42,8 @@ export declare const assertFieldAppearanceOptions: (options?: FieldAppearanceOpt
  * to be rendered.
  */
 export default class PDFField {
+    static className: () => PDFClasses;
+    myClass(): PDFClasses;
     /** The low-level PDFAcroTerminal wrapped by this field. */
     readonly acroField: PDFAcroTerminal;
     /** The unique reference assigned to this field within the document. */

package/ts3.4/cjs/api/form/PDFOptionList.d.ts

@@ -4,6 +4,7 @@ import PDFFont from '../PDFFont';
 import PDFField, { FieldAppearanceOptions } from './PDFField';
 import { AppearanceProviderFor } from './appearances';
 import { PDFRef, PDFAcroListBox } from '../../core';
+import { PDFClasses } from '../objects';
 /**
  * Represents an option list field of a [[PDFForm]].
  *
@@ -16,6 +17,8 @@ import { PDFRef, PDFAcroListBox } from '../../core';
  * more than one option (see [[PDFOptionList.isMultiselect]]).
  */
 export default class PDFOptionList extends PDFField {
+    static className: () => PDFClasses;
+    myClass(): PDFClasses;
     /**
      * > **NOTE:** You probably don't want to call this method directly. Instead,
      * > consider using the [[PDFForm.getOptionList]] method, which will create

package/ts3.4/cjs/api/form/PDFRadioGroup.d.ts

@@ -3,6 +3,7 @@ import PDFPage from '../PDFPage';
 import PDFField, { FieldAppearanceOptions } from './PDFField';
 import { AppearanceProviderFor } from './appearances';
 import { PDFRef, PDFAcroRadioButton } from '../../core';
+import { PDFClasses } from '../objects';
 /**
  * Represents a radio group field of a [[PDFForm]].
  *
@@ -21,6 +22,8 @@ import { PDFRef, PDFAcroRadioButton } from '../../core';
  * [[PDFRadioGroup.isMutuallyExclusive]]).
  */
 export default class PDFRadioGroup extends PDFField {
+    static className: () => PDFClasses;
+    myClass(): PDFClasses;
     /**
      * > **NOTE:** You probably don't want to call this method directly. Instead,
      * > consider using the [[PDFForm.getOptionList]] method, which will create an

package/ts3.4/cjs/api/form/PDFSignature.d.ts

@@ -1,6 +1,7 @@
 import PDFDocument from '../PDFDocument';
 import PDFField from './PDFField';
 import { PDFRef, PDFAcroSignature } from '../../core';
+import { PDFClasses } from '../objects';
 /**
  * Represents a signature field of a [[PDFForm]].
  *
@@ -9,6 +10,8 @@ import { PDFRef, PDFAcroSignature } from '../../core';
  * reading the contents of existing digital signatures.
  */
 export default class PDFSignature extends PDFField {
+    static className: () => PDFClasses;
+    myClass(): PDFClasses;
     /**
      * > **NOTE:** You probably don't want to call this method directly. Instead,
      * > consider using the [[PDFForm.getSignature]] method, which will create an

package/ts3.4/cjs/api/form/PDFTextField.d.ts

@@ -6,6 +6,7 @@ import PDFField, { FieldAppearanceOptions } from './PDFField';
 import { AppearanceProviderFor } from './appearances';
 import { TextAlignment } from '../text/alignment';
 import { PDFRef, PDFAcroText } from '../../core';
+import { PDFClasses } from '../objects';
 /**
  * Represents a text field of a [[PDFForm]].
  *
@@ -16,6 +17,8 @@ import { PDFRef, PDFAcroText } from '../../core';
  * to be entered (see [[PDFTextField.isMultiline]]).
  */
 export default class PDFTextField extends PDFField {
+    static className: () => PDFClasses;
+    myClass(): PDFClasses;
     /**
      * > **NOTE:** You probably don't want to call this method directly. Instead,
      * > consider using the [[PDFForm.getTextField]] method, which will create an

package/ts3.4/cjs/api/objects.d.ts

@@ -2,4 +2,65 @@ import { PDFName, PDFNumber } from '../core';
 export declare const asPDFName: (name: string | PDFName) => PDFName;
 export declare const asPDFNumber: (num: number | PDFNumber) => PDFNumber;
 export declare const asNumber: (num: number | PDFNumber) => number;
+export declare enum PDFClasses {
+    PDFDict = "PDFDict",
+    PDFObject = "PDFObject",
+    PDFNumber = "PDFNumber",
+    PDFName = "PDFName",
+    PDFStream = "PDFStream",
+    PDFWriter = "PDFWriter",
+    PDFStreamWriter = "PDFStreamWriter",
+    PDFString = "PDFString",
+    PDFHexString = "PDFHexString",
+    PDFDocument = "PDFDocument",
+    PDFPageLeaf = "PDFPageLeaf",
+    StandardFontEmbedder = "StandardFontEmbedder",
+    PDFArray = "PDFArray",
+    PDFButton = "PDFButton",
+    PDFCheckBox = "PDFCheckBox",
+    PDFDropdown = "PDFDropdown",
+    PDFOptionList = "PDFOptionList",
+    PDFRadioGroup = "PDFRadioGroup",
+    PDFSignature = "PDFSignature",
+    PDFTextField = "PDFTextField",
+    PDFField = "PDFField",
+    PDFRef = "PDFRef",
+    PDFAcroForm = "PDFAcroForm",
+    PDFAcroField = "PDFAcroField",
+    PDFAcroNonTerminal = "PDFAcroNonTerminal",
+    PDFAcroPushButton = "PDFAcroPushButton",
+    PDFAcroCheckBox = "PDFAcroCheckBox",
+    PDFAcroComboBox = "PDFAcroComboBox",
+    PDFAcroListBox = "PDFAcroListBox",
+    PDFAcroText = "PDFAcroText",
+    PDFAcroRadioButton = "PDFAcroRadioButton",
+    PDFAcroSignature = "PDFAcroSignature",
+    AESBaseCipher = "AESBaseCipher",
+    PDFBool = "PDFBool",
+    PDFRawStream = "PDFRawStream",
+    PDFContentStream = "PDFContentStream",
+    Segment = "Segment",
+    Rectangle = "Rectangle",
+    Arc = "Arc",
+    Circle = "Circle",
+    Ellipse = "Ellipse",
+    Line = "Line",
+    Plot = "Plot",
+    Point = "Point",
+    PDFPageTree = "PDFPageTree",
+    PDFInvalidObject = "PDFInvalidObject",
+    PDFCatalog = "PDFCatalog",
+    DefaultDocumentSnapshot = "DefaultDocumentSnapshot",
+    PDFObjectStream = "PDFObjectStream",
+    IncrementalDocumentSnapshot = "IncrementalDocumentSnapshot",
+    PDFNull = "PDFNull"
+}
+/**
+ * Replaces instanceof operator by a "secure function" that uses clases internal identification.
+ * This allows complex environments, where objects comes from different library instances, to work as expected.
+ * @param {any} object Object to which compare the classname.
+ * @param {PDFClasses | typeof PDFClass} className Class name object is expected to be an instanca (or subclass instance)
+ * @returns {boolean}
+ */
+export declare const isPDFInstance: (object: any, className: PDFClasses) => boolean;
 //# sourceMappingURL=objects.d.ts.map