@pdfme/pdf-lib 0.0.0

package/dist/types/src/core/acroform/PDFAcroButton.d.ts

@@ -0,0 +1,21 @@
+import PDFObject from '../objects/PDFObject';
+import PDFString from '../objects/PDFString';
+import PDFHexString from '../objects/PDFHexString';
+import PDFArray from '../objects/PDFArray';
+import PDFName from '../objects/PDFName';
+import PDFRef from '../objects/PDFRef';
+import PDFAcroTerminal from './PDFAcroTerminal';
+declare class PDFAcroButton extends PDFAcroTerminal {
+    Opt(): PDFString | PDFHexString | PDFArray | undefined;
+    setOpt(opt: PDFObject[]): void;
+    getExportValues(): (PDFString | PDFHexString)[] | undefined;
+    removeExportValue(idx: number): void;
+    normalizeExportValues(): void;
+    /**
+     * Reuses existing opt if one exists with the same value (assuming
+     * `useExistingIdx` is `true`). Returns index of existing (or new) opt.
+     */
+    addOpt(opt: PDFHexString | PDFString, useExistingOptIdx: boolean): number;
+    addWidgetWithOpt(widget: PDFRef, opt: PDFHexString | PDFString, useExistingOptIdx: boolean): PDFName;
+}
+export default PDFAcroButton;

package/dist/types/src/core/acroform/PDFAcroCheckBox.d.ts

@@ -0,0 +1,13 @@
+import PDFContext from '../PDFContext';
+import PDFRef from '../objects/PDFRef';
+import PDFDict from '../objects/PDFDict';
+import PDFName from '../objects/PDFName';
+import PDFAcroButton from './PDFAcroButton';
+declare class PDFAcroCheckBox extends PDFAcroButton {
+    static fromDict: (dict: PDFDict, ref: PDFRef) => PDFAcroCheckBox;
+    static create: (context: PDFContext) => PDFAcroCheckBox;
+    setValue(value: PDFName): void;
+    getValue(): PDFName;
+    getOnValue(): PDFName | undefined;
+}
+export default PDFAcroCheckBox;

package/dist/types/src/core/acroform/PDFAcroChoice.d.ts

@@ -0,0 +1,20 @@
+import PDFAcroTerminal from './PDFAcroTerminal';
+import PDFHexString from '../objects/PDFHexString';
+import PDFString from '../objects/PDFString';
+import PDFArray from '../objects/PDFArray';
+declare class PDFAcroChoice extends PDFAcroTerminal {
+    setValues(values: (PDFString | PDFHexString)[]): void;
+    valuesAreValid(values: (PDFString | PDFHexString)[]): boolean;
+    updateSelectedIndices(values: (PDFString | PDFHexString)[]): void;
+    getValues(): (PDFString | PDFHexString)[];
+    Opt(): PDFArray | PDFString | PDFHexString | undefined;
+    setOptions(options: {
+        value: PDFString | PDFHexString;
+        display?: PDFString | PDFHexString;
+    }[]): void;
+    getOptions(): {
+        value: PDFString | PDFHexString;
+        display: PDFString | PDFHexString;
+    }[];
+}
+export default PDFAcroChoice;

package/dist/types/src/core/acroform/PDFAcroComboBox.d.ts

@@ -0,0 +1,9 @@
+import PDFDict from '../objects/PDFDict';
+import PDFAcroChoice from './PDFAcroChoice';
+import PDFContext from '../PDFContext';
+import PDFRef from '../objects/PDFRef';
+declare class PDFAcroComboBox extends PDFAcroChoice {
+    static fromDict: (dict: PDFDict, ref: PDFRef) => PDFAcroComboBox;
+    static create: (context: PDFContext) => PDFAcroComboBox;
+}
+export default PDFAcroComboBox;

package/dist/types/src/core/acroform/PDFAcroField.d.ts

@@ -0,0 +1,36 @@
+import PDFDict from '../objects/PDFDict';
+import PDFString from '../objects/PDFString';
+import PDFHexString from '../objects/PDFHexString';
+import PDFName from '../objects/PDFName';
+import PDFObject from '../objects/PDFObject';
+import PDFNumber from '../objects/PDFNumber';
+import PDFArray from '../objects/PDFArray';
+import PDFRef from '../objects/PDFRef';
+declare class PDFAcroField {
+    readonly dict: PDFDict;
+    readonly ref: PDFRef;
+    protected constructor(dict: PDFDict, ref: PDFRef);
+    T(): PDFString | PDFHexString | undefined;
+    Ff(): PDFNumber | undefined;
+    V(): PDFObject | undefined;
+    Kids(): PDFArray | undefined;
+    DA(): PDFString | PDFHexString | undefined;
+    setKids(kids: PDFObject[]): void;
+    getParent(): PDFAcroField | undefined;
+    setParent(parent: PDFRef | undefined): void;
+    getFullyQualifiedName(): string | undefined;
+    getPartialName(): string | undefined;
+    setPartialName(partialName: string | undefined): void;
+    setDefaultAppearance(appearance: string): void;
+    getDefaultAppearance(): string | undefined;
+    setFontSize(fontSize: number): void;
+    getFlags(): number;
+    setFlags(flags: number): void;
+    hasFlag(flag: number): boolean;
+    setFlag(flag: number): void;
+    clearFlag(flag: number): void;
+    setFlagTo(flag: number, enable: boolean): void;
+    getInheritableAttribute(name: PDFName): PDFObject | undefined;
+    ascend(visitor: (node: PDFAcroField) => any): void;
+}
+export default PDFAcroField;

package/dist/types/src/core/acroform/PDFAcroForm.d.ts

@@ -0,0 +1,20 @@
+import PDFContext from '../PDFContext';
+import PDFDict from '../objects/PDFDict';
+import PDFArray from '../objects/PDFArray';
+import PDFRef from '../objects/PDFRef';
+import PDFAcroField from './PDFAcroField';
+declare class PDFAcroForm {
+    readonly dict: PDFDict;
+    static fromDict: (dict: PDFDict) => PDFAcroForm;
+    static create: (context: PDFContext) => PDFAcroForm;
+    private constructor();
+    Fields(): PDFArray | undefined;
+    getFields(): [PDFAcroField, PDFRef][];
+    getAllFields(): [PDFAcroField, PDFRef][];
+    addField(field: PDFRef): void;
+    removeField(field: PDFAcroField): void;
+    normalizedEntries(): {
+        Fields: PDFArray;
+    };
+}
+export default PDFAcroForm;

package/dist/types/src/core/acroform/PDFAcroListBox.d.ts

@@ -0,0 +1,9 @@
+import PDFDict from '../objects/PDFDict';
+import PDFAcroChoice from './PDFAcroChoice';
+import PDFContext from '../PDFContext';
+import PDFRef from '../objects/PDFRef';
+declare class PDFAcroListBox extends PDFAcroChoice {
+    static fromDict: (dict: PDFDict, ref: PDFRef) => PDFAcroListBox;
+    static create: (context: PDFContext) => PDFAcroListBox;
+}
+export default PDFAcroListBox;

package/dist/types/src/core/acroform/PDFAcroNonTerminal.d.ts

@@ -0,0 +1,13 @@
+import PDFDict from '../objects/PDFDict';
+import PDFRef from '../objects/PDFRef';
+import PDFContext from '../PDFContext';
+import PDFAcroField from './PDFAcroField';
+declare class PDFAcroNonTerminal extends PDFAcroField {
+    static fromDict: (dict: PDFDict, ref: PDFRef) => PDFAcroNonTerminal;
+    static create: (context: PDFContext) => PDFAcroNonTerminal;
+    addField(field: PDFRef): void;
+    normalizedEntries(): {
+        Kids: import("..").PDFArray;
+    };
+}
+export default PDFAcroNonTerminal;

package/dist/types/src/core/acroform/PDFAcroPushButton.d.ts

@@ -0,0 +1,9 @@
+import PDFDict from '../objects/PDFDict';
+import PDFAcroButton from './PDFAcroButton';
+import PDFContext from '../PDFContext';
+import PDFRef from '../objects/PDFRef';
+declare class PDFAcroPushButton extends PDFAcroButton {
+    static fromDict: (dict: PDFDict, ref: PDFRef) => PDFAcroPushButton;
+    static create: (context: PDFContext) => PDFAcroPushButton;
+}
+export default PDFAcroPushButton;

package/dist/types/src/core/acroform/PDFAcroRadioButton.d.ts

@@ -0,0 +1,13 @@
+import PDFRef from '../objects/PDFRef';
+import PDFDict from '../objects/PDFDict';
+import PDFName from '../objects/PDFName';
+import PDFAcroButton from './PDFAcroButton';
+import PDFContext from '../PDFContext';
+declare class PDFAcroRadioButton extends PDFAcroButton {
+    static fromDict: (dict: PDFDict, ref: PDFRef) => PDFAcroRadioButton;
+    static create: (context: PDFContext) => PDFAcroRadioButton;
+    setValue(value: PDFName): void;
+    getValue(): PDFName;
+    getOnValues(): PDFName[];
+}
+export default PDFAcroRadioButton;

package/dist/types/src/core/acroform/PDFAcroSignature.d.ts

@@ -0,0 +1,7 @@
+import PDFDict from '../objects/PDFDict';
+import PDFRef from '../objects/PDFRef';
+import PDFAcroTerminal from './PDFAcroTerminal';
+declare class PDFAcroSignature extends PDFAcroTerminal {
+    static fromDict: (dict: PDFDict, ref: PDFRef) => PDFAcroSignature;
+}
+export default PDFAcroSignature;

package/dist/types/src/core/acroform/PDFAcroTerminal.d.ts

@@ -0,0 +1,16 @@
+import PDFDict from '../objects/PDFDict';
+import PDFName from '../objects/PDFName';
+import PDFRef from '../objects/PDFRef';
+import PDFAcroField from './PDFAcroField';
+import PDFWidgetAnnotation from '../annotation/PDFWidgetAnnotation';
+declare class PDFAcroTerminal extends PDFAcroField {
+    static fromDict: (dict: PDFDict, ref: PDFRef) => PDFAcroTerminal;
+    FT(): PDFName;
+    getWidgets(): PDFWidgetAnnotation[];
+    addWidget(ref: PDFRef): void;
+    removeWidget(idx: number): void;
+    normalizedEntries(): {
+        Kids: import("..").PDFArray;
+    };
+}
+export default PDFAcroTerminal;

package/dist/types/src/core/acroform/PDFAcroText.d.ts

@@ -0,0 +1,22 @@
+import PDFContext from '../PDFContext';
+import PDFDict from '../objects/PDFDict';
+import PDFNumber from '../objects/PDFNumber';
+import PDFString from '../objects/PDFString';
+import PDFHexString from '../objects/PDFHexString';
+import PDFRef from '../objects/PDFRef';
+import PDFAcroTerminal from './PDFAcroTerminal';
+declare class PDFAcroText extends PDFAcroTerminal {
+    static fromDict: (dict: PDFDict, ref: PDFRef) => PDFAcroText;
+    static create: (context: PDFContext) => PDFAcroText;
+    MaxLen(): PDFNumber | undefined;
+    Q(): PDFNumber | undefined;
+    setMaxLength(maxLength: number): void;
+    removeMaxLength(): void;
+    getMaxLength(): number | undefined;
+    setQuadding(quadding: 0 | 1 | 2): void;
+    getQuadding(): number | undefined;
+    setValue(value: PDFHexString | PDFString): void;
+    removeValue(): void;
+    getValue(): PDFString | PDFHexString | undefined;
+}
+export default PDFAcroText;

package/dist/types/src/core/acroform/flags.d.ts

@@ -0,0 +1,141 @@
+/** From PDF spec table 221 */
+export declare enum AcroFieldFlags {
+    /**
+     * If set, the user may not change the value of the field. Any associated
+     * widget annotations will not interact with the user; that is, they will not
+     * respond to mouse clicks or change their appearance in response to mouse
+     * motions. This flag is useful for fields whose values are computed or
+     * imported from a database.
+     */
+    ReadOnly,
+    /**
+     * If set, the field shall have a value at the time it is exported by a
+     * submit-form action (see 12.7.5.2, "Submit-Form Action").
+     */
+    Required,
+    /**
+     * If set, the field shall not be exported by a submit-form action
+     * (see 12.7.5.2, "Submit-Form Action").
+     */
+    NoExport
+}
+/** From PDF spec table 226 */
+export declare enum AcroButtonFlags {
+    /**
+     * (Radio buttons only) If set, exactly one radio button shall be selected at
+     * all times; selecting the currently selected button has no effect. If clear,
+     * clicking the selected button deselects it, leaving no button selected.
+     */
+    NoToggleToOff,
+    /**
+     * If set, the field is a set of radio buttons; if clear, the field is a check
+     * box. This flag may be set only if the Pushbutton flag is clear.
+     */
+    Radio,
+    /**
+     * If set, the field is a pushbutton that does not retain a permanent value.
+     */
+    PushButton,
+    /**
+     * If set, a group of radio buttons within a radio button field that use the
+     * same value for the on state will turn on and off in unison; that is if one
+     * is checked, they are all checked. If clear, the buttons are mutually
+     * exclusive (the same behavior as HTML radio buttons).
+     */
+    RadiosInUnison
+}
+/** From PDF spec table 228 */
+export declare enum AcroTextFlags {
+    /**
+     * If set, the field may contain multiple lines of text; if clear, the field's
+     * text shall be restricted to a single line.
+     */
+    Multiline,
+    /**
+     * If set, the field is intended for entering a secure password that should
+     * not be echoed visibly to the screen. Characters typed from the keyboard
+     * shall instead be echoed in some unreadable form, such as asterisks or
+     * bullet characters.
+     * > NOTE   To protect password confidentiality, readers should never store
+     * >        the value of the text field in the PDF file if this flag is set.
+     */
+    Password,
+    /**
+     * If set, the text entered in the field represents the pathname of a file
+     * whose contents shall be submitted as the value of the field.
+     */
+    FileSelect,
+    /**
+     * If set, text entered in the field shall not be spell-checked.
+     */
+    DoNotSpellCheck,
+    /**
+     * If set, the field shall not scroll (horizontally for single-line fields,
+     * vertically for multiple-line fields) to accommodate more text than fits
+     * within its annotation rectangle. Once the field is full, no further text
+     * shall be accepted for interactive form filling; for non-interactive form
+     * filling, the filler should take care not to add more character than will
+     * visibly fit in the defined area.
+     */
+    DoNotScroll,
+    /**
+     * May be set only if the MaxLen entry is present in the text field dictionary
+     * (see Table 229) and if the Multiline, Password, and FileSelect flags are
+     * clear. If set, the field shall be automatically divided into as many
+     * equally spaced positions, or combs, as the value of MaxLen, and the text
+     * is laid out into those combs.
+     */
+    Comb,
+    /**
+     * If set, the value of this field shall be a rich text string
+     * (see 12.7.3.4, "Rich Text Strings"). If the field has a value, the RV
+     * entry of the field dictionary (Table 222) shall specify the rich text
+     * string.
+     */
+    RichText
+}
+/** From PDF spec table 230 */
+export declare enum AcroChoiceFlags {
+    /**
+     * If set, the field is a combo box; if clear, the field is a list box.
+     */
+    Combo,
+    /**
+     * If set, the combo box shall include an editable text box as well as a
+     * drop-down list; if clear, it shall include only a drop-down list. This
+     * flag shall be used only if the Combo flag is set.
+     */
+    Edit,
+    /**
+     * If set, the field's option items shall be sorted alphabetically. This flag
+     * is intended for use by writers, not by readers. Conforming readers shall
+     * display the options in the order in which they occur in the Opt array
+     * (see Table 231).
+     */
+    Sort,
+    /**
+     * If set, more than one of the field's option items may be selected
+     * simultaneously; if clear, at most one item shall be selected.
+     */
+    MultiSelect,
+    /**
+     * If set, text entered in the field shall not be spell-checked. This flag
+     * shall not be used unless the Combo and Edit flags are both set.
+     */
+    DoNotSpellCheck,
+    /**
+     * If set, the new value shall be committed as soon as a selection is made
+     * (commonly with the pointing device). In this case, supplying a value for
+     * a field involves three actions: selecting the field for fill-in,
+     * selecting a choice for the fill-in value, and leaving that field, which
+     * finalizes or "commits" the data choice and triggers any actions associated
+     * with the entry or changing of this data. If this flag is on, then
+     * processing does not wait for leaving the field action to occur, but
+     * immediately proceeds to the third step.
+     *
+     * This option enables applications to perform an action once a selection is
+     * made, without requiring the user to exit the field. If clear, the new
+     * value is not committed until the user exits the field.
+     */
+    CommitOnSelChange
+}

package/dist/types/src/core/acroform/index.d.ts

@@ -0,0 +1,15 @@
+export { default as PDFAcroButton } from './PDFAcroButton';
+export { default as PDFAcroCheckBox } from './PDFAcroCheckBox';
+export { default as PDFAcroChoice } from './PDFAcroChoice';
+export { default as PDFAcroComboBox } from './PDFAcroComboBox';
+export { default as PDFAcroField } from './PDFAcroField';
+export { default as PDFAcroForm } from './PDFAcroForm';
+export { default as PDFAcroListBox } from './PDFAcroListBox';
+export { default as PDFAcroNonTerminal } from './PDFAcroNonTerminal';
+export { default as PDFAcroPushButton } from './PDFAcroPushButton';
+export { default as PDFAcroRadioButton } from './PDFAcroRadioButton';
+export { default as PDFAcroSignature } from './PDFAcroSignature';
+export { default as PDFAcroTerminal } from './PDFAcroTerminal';
+export { default as PDFAcroText } from './PDFAcroText';
+export * from './flags';
+export * from './utils';

package/dist/types/src/core/acroform/utils.d.ts

@@ -0,0 +1,6 @@
+import PDFDict from '../objects/PDFDict';
+import PDFArray from '../objects/PDFArray';
+import PDFRef from '../objects/PDFRef';
+import PDFAcroField from './PDFAcroField';
+export declare const createPDFAcroFields: (kidDicts?: PDFArray) => [PDFAcroField, PDFRef][];
+export declare const createPDFAcroField: (dict: PDFDict, ref: PDFRef) => PDFAcroField;

package/dist/types/src/core/annotation/AppearanceCharacteristics.d.ts

@@ -0,0 +1,33 @@
+import PDFDict from '../objects/PDFDict';
+import PDFNumber from '../objects/PDFNumber';
+import PDFArray from '../objects/PDFArray';
+import PDFHexString from '../objects/PDFHexString';
+import PDFString from '../objects/PDFString';
+declare class AppearanceCharacteristics {
+    readonly dict: PDFDict;
+    static fromDict: (dict: PDFDict) => AppearanceCharacteristics;
+    protected constructor(dict: PDFDict);
+    R(): PDFNumber | undefined;
+    BC(): PDFArray | undefined;
+    BG(): PDFArray | undefined;
+    CA(): PDFHexString | PDFString | undefined;
+    RC(): PDFHexString | PDFString | undefined;
+    AC(): PDFHexString | PDFString | undefined;
+    getRotation(): number | undefined;
+    getBorderColor(): number[] | undefined;
+    getBackgroundColor(): number[] | undefined;
+    getCaptions(): {
+        normal?: string;
+        rollover?: string;
+        down?: string;
+    };
+    setRotation(rotation: number): void;
+    setBorderColor(color: number[]): void;
+    setBackgroundColor(color: number[]): void;
+    setCaptions(captions: {
+        normal: string;
+        rollover?: string;
+        down?: string;
+    }): void;
+}
+export default AppearanceCharacteristics;

package/dist/types/src/core/annotation/BorderStyle.d.ts

@@ -0,0 +1,11 @@
+import PDFDict from '../objects/PDFDict';
+import PDFNumber from '../objects/PDFNumber';
+declare class BorderStyle {
+    readonly dict: PDFDict;
+    static fromDict: (dict: PDFDict) => BorderStyle;
+    protected constructor(dict: PDFDict);
+    W(): PDFNumber | undefined;
+    getWidth(): number | undefined;
+    setWidth(width: number): void;
+}
+export default BorderStyle;

package/dist/types/src/core/annotation/PDFAnnotation.d.ts

@@ -0,0 +1,51 @@
+import PDFDict from '../objects/PDFDict';
+import PDFName from '../objects/PDFName';
+import PDFStream from '../objects/PDFStream';
+import PDFArray from '../objects/PDFArray';
+import PDFRef from '../objects/PDFRef';
+import PDFNumber from '../objects/PDFNumber';
+declare class PDFAnnotation {
+    readonly dict: PDFDict;
+    static fromDict: (dict: PDFDict) => PDFAnnotation;
+    protected constructor(dict: PDFDict);
+    Rect(): PDFArray | undefined;
+    AP(): PDFDict | undefined;
+    F(): PDFNumber | undefined;
+    getRectangle(): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    setRectangle(rect: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }): void;
+    getAppearanceState(): PDFName | undefined;
+    setAppearanceState(state: PDFName): void;
+    setAppearances(appearances: PDFDict): void;
+    ensureAP(): PDFDict;
+    getNormalAppearance(): PDFRef | PDFDict;
+    /** @param appearance A PDFDict or PDFStream (direct or ref) */
+    setNormalAppearance(appearance: PDFRef | PDFDict): void;
+    /** @param appearance A PDFDict or PDFStream (direct or ref) */
+    setRolloverAppearance(appearance: PDFRef | PDFDict): void;
+    /** @param appearance A PDFDict or PDFStream (direct or ref) */
+    setDownAppearance(appearance: PDFRef | PDFDict): void;
+    removeRolloverAppearance(): void;
+    removeDownAppearance(): void;
+    getAppearances(): {
+        normal: PDFStream | PDFDict;
+        rollover?: PDFStream | PDFDict;
+        down?: PDFStream | PDFDict;
+    } | undefined;
+    getFlags(): number;
+    setFlags(flags: number): void;
+    hasFlag(flag: number): boolean;
+    setFlag(flag: number): void;
+    clearFlag(flag: number): void;
+    setFlagTo(flag: number, enable: boolean): void;
+}
+export default PDFAnnotation;

package/dist/types/src/core/annotation/PDFWidgetAnnotation.d.ts

@@ -0,0 +1,26 @@
+import PDFDict from '../objects/PDFDict';
+import PDFName from '../objects/PDFName';
+import PDFRef from '../objects/PDFRef';
+import PDFString from '../objects/PDFString';
+import PDFHexString from '../objects/PDFHexString';
+import PDFContext from '../PDFContext';
+import BorderStyle from './BorderStyle';
+import PDFAnnotation from './PDFAnnotation';
+import AppearanceCharacteristics from './AppearanceCharacteristics';
+declare class PDFWidgetAnnotation extends PDFAnnotation {
+    static fromDict: (dict: PDFDict) => PDFWidgetAnnotation;
+    static create: (context: PDFContext, parent: PDFRef) => PDFWidgetAnnotation;
+    MK(): PDFDict | undefined;
+    BS(): PDFDict | undefined;
+    DA(): PDFString | PDFHexString | undefined;
+    P(): PDFRef | undefined;
+    setP(page: PDFRef): void;
+    setDefaultAppearance(appearance: string): void;
+    getDefaultAppearance(): string | undefined;
+    getAppearanceCharacteristics(): AppearanceCharacteristics | undefined;
+    getOrCreateAppearanceCharacteristics(): AppearanceCharacteristics;
+    getBorderStyle(): BorderStyle | undefined;
+    getOrCreateBorderStyle(): BorderStyle;
+    getOnValue(): PDFName | undefined;
+}
+export default PDFWidgetAnnotation;

package/dist/types/src/core/annotation/flags.d.ts

@@ -0,0 +1,79 @@
+/** From PDF spec table 165 */
+export declare enum AnnotationFlags {
+    /**
+     * If set, do not display the annotation if it does not belong to one of the
+     * standard annotation types and no annotation handler is available. If clear,
+     * display such an unknown annotation using an appearance stream specified by
+     * its appearance dictionary, if any.
+     */
+    Invisible,
+    /**
+     * If set, do not display or print the annotation or allow it to interact with
+     * the user, regardless of its annotation type or whether an annotation
+     * handler is available.
+     *
+     * In cases where screen space is limited, the ability to hide and show
+     * annotations selectively can be used in combination with appearance streams
+     * to display auxiliary pop-up information similar in function to online help
+     * systems.
+     */
+    Hidden,
+    /**
+     * If set, print the annotation when the page is printed. If clear, never
+     * print the annotation, regardless of whether it is displayed on the screen.
+     *
+     * This can be useful for annotations representing interactive pushbuttons,
+     * which would serve no meaningful purpose on the printed page.
+     */
+    Print,
+    /**
+     * If set, do not scale the annotation’s appearance to match the magnification
+     * of the page. The location of the annotation on the page (defined by the
+     * upper-left corner of its annotation rectangle) shall remain fixed,
+     * regardless of the page magnification.
+     */
+    NoZoom,
+    /**
+     * If set, do not rotate the annotation’s appearance to match the rotation of
+     * the page. The upper-left corner of the annotation rectangle shall remain in
+     * a fixed location on the page, regardless of the page rotation.
+     */
+    NoRotate,
+    /**
+     * If set, do not display the annotation on the screen or allow it to interact
+     * with the user. The annotation may be printed (depending on the setting of
+     * the Print flag) but should be considered hidden for purposes of on-screen
+     * display and user interaction.
+     */
+    NoView,
+    /**
+     * If set, do not allow the annotation to interact with the user. The
+     * annotation may be displayed or printed (depending on the settings of the
+     * NoView and Print flags) but should not respond to mouse clicks or change
+     * its appearance in response to mouse motions.
+     *
+     * This flag shall be ignored for widget annotations; its function is
+     * subsumed by the ReadOnly flag of the associated form field.
+     */
+    ReadOnly,
+    /**
+     * If set, do not allow the annotation to be deleted or its properties
+     * (including position and size) to be modified by the user. However, this
+     * flag does not restrict changes to the annotation’s contents, such as the
+     * value of a form field.
+     */
+    Locked,
+    /**
+     * If set, invert the interpretation of the NoView flag for certain events.
+     *
+     * A typical use is to have an annotation that appears only when a mouse
+     * cursor is held over it.
+     */
+    ToggleNoView,
+    /**
+     * If set, do not allow the contents of the annotation to be modified by the
+     * user. This flag does not restrict deletion of the annotation or changes to
+     * other annotation properties, such as position and size.
+     */
+    LockedContents
+}

package/dist/types/src/core/annotation/index.d.ts

@@ -0,0 +1,4 @@
+export { default as PDFAnnotation } from './PDFAnnotation';
+export { default as PDFWidgetAnnotation } from './PDFWidgetAnnotation';
+export { default as AppearanceCharacteristics } from './AppearanceCharacteristics';
+export * from './flags';