@grapecity-software/gcdocs.pdfviewer 7.1.0

package/typings/Utils/RichMediaAnnotationPlayer.d.ts

@@ -0,0 +1,60 @@
+import { RichMediaAnnotation } from "../Annotations/RichMediaAnnotation";
+export declare function exitPictureInPictureMode(videoElement: HTMLVideoElement): Promise<void>;
+export declare function requestPictureInPictureMode(videoElement: HTMLVideoElement): Promise<boolean>;
+export declare class RichMediaAnnotationPlayer {
+    container: HTMLElement;
+    richMediaAnnotation: RichMediaAnnotation;
+    viewer: any;
+    private _initialized;
+    private _html5MediaElement;
+    private _unregisterViewerStateChange?;
+    private _intersectionObserver?;
+    private _audioOscilloscopeVisualizer?;
+    private _streamVideoElement?;
+    constructor(container: HTMLElement, richMediaAnnotation: RichMediaAnnotation, viewer: any);
+    get activationCondition(): "XA" | "PO" | "PV";
+    get deactivationCondition(): "XD" | "PC" | "PI";
+    get annotationPageIndex(): number;
+    get fileSpec(): {
+        content: Uint8Array;
+        filename: string;
+    };
+    get isFlash(): boolean;
+    get isMp3(): boolean;
+    get isAudio(): boolean;
+    get mimeType(): string;
+    get isWindowed(): boolean;
+    get lowerFileName(): string;
+    get paused(): boolean;
+    togglePlayback(): void;
+    play(): void;
+    protected get richMediaAnnotationElement(): HTMLElement | undefined;
+    protected onPlaybackStarted(): void;
+    protected onPlaybackStopped(): void;
+    get isPlaybackActivated(): boolean;
+    stop(): void;
+    pause(): void;
+    private onViewerStateChange;
+    get in17n(): any;
+    onContentClick(): void;
+    private initializeInternal;
+    showClickToActivateTooltip(): void;
+    hideClickToActivateTooltip(): void;
+    private pauseHtml5Media;
+    private stopHtml5Media;
+    private _ensureHtml5MediaElement;
+    onEnterPictureInPicture(): void;
+    onLeavePictureInPicture(): void;
+    private playHtml5Media;
+    private tryExitPipMode;
+    private removeCustomPiP;
+    private createCustomPiP;
+    private tryEnterPipMode;
+    private static stopSwf;
+    private static playSwf;
+    private static playSwfInternal;
+    private get isEditAnnotationsMode();
+    private disposeIfNecessary;
+    private disposeViewerStateChange;
+    private disposeIntersectionObserver;
+}

package/typings/Utils/ScrollUtils.d.ts

@@ -0,0 +1,20 @@
+export declare function scrollIntoView(element: HTMLElement, spot: {
+    left?: number;
+    top?: number;
+}, skipOverflowHiddenElements?: boolean, parent?: any | null): void;
+export declare class GcDebounceScroll {
+    state: {
+        down: boolean;
+        lastScrollTop: number;
+    };
+    private _debounceScrollHandler?;
+    private _requestAnimationFrame;
+    private _scrollContainer;
+    private _cancelUnhandledScrolls;
+    private _cancelledScrollValue;
+    constructor(scrollContainer: HTMLElement, callback: Function, restoreCancelledScrollCallback?: Function | null | undefined);
+    setScrollContainer(scrollContainer: any): void;
+    set cancelUnhandledScrolls(cancel: boolean);
+    get cancelUnhandledScrolls(): boolean;
+    destroy(): void;
+}

package/typings/Utils/SearchUtils.d.ts

@@ -0,0 +1,20 @@
+export declare function isTextPartsOnTheSameLine(first: {
+    transform: number[];
+    dir: 'ltr' | 'rtl';
+}, next: {
+    transform: number[];
+    dir: 'ltr' | 'rtl';
+}): boolean;
+declare const CharacterType: {
+    SPACE: number;
+    ALPHA_LETTER: number;
+    PUNCT: number;
+    HAN_LETTER: number;
+    KATAKANA_LETTER: number;
+    HIRAGANA_LETTER: number;
+    HALFWIDTH_KATAKANA_LETTER: number;
+    THAI_LETTER: number;
+};
+declare function normalize(text: any): any;
+declare function getCharacterType(charCode: any): number;
+export { CharacterType, getCharacterType, normalize };

package/typings/Utils/SelectionRangeUtils.d.ts

@@ -0,0 +1,2 @@
+export declare function getCaretPosition(contentEditableElement: HTMLElement, docOrShadowRoot?: Document | ShadowRoot): number;
+export declare function setCaretPosition(contentEditableElement: HTMLElement, caretPos: number, docOrShadowRoot?: Document | ShadowRoot): void;

package/typings/Utils/SharedRef.d.ts

@@ -0,0 +1,17 @@
+import { DataStorage } from "../DataStorage/DataStorage";
+export declare class SharedRef {
+    viewer: any;
+    moment: any;
+    i18n: any;
+    static onViewerInitialize(viewer: any, moment: any): void;
+    static get(instanceId: string, getAny?: boolean): SharedRef;
+    static dispose(instanceId: string): void;
+    static get moment(): any;
+    static get i18n(): any;
+    static set i18n(i18n: any);
+    static get count(): number;
+    constructor(viewer: any, moment: any, i18n: any);
+    get storage(): DataStorage;
+    dispose(): void;
+    releaseResources(): void;
+}

package/typings/Utils/StampImagesAwaiter.d.ts

@@ -0,0 +1,15 @@
+import PdfReportPlugin from "../plugin";
+export declare class StampImagesAwaiter {
+    private plugin;
+    private _loadedImagesInfoHash;
+    constructor(plugin: PdfReportPlugin);
+    onAnnotationImageLoaded(info: {
+        id: string;
+        fileId: string;
+        fileName: string;
+        fileLength: number;
+        filePropName?: string;
+    }): void;
+    private _applyLoadedImagesInfo;
+    private setStampAnnotationFile;
+}

package/typings/Utils/SupportApiUtils.d.ts

@@ -0,0 +1,4 @@
+import { SaveSettings } from "../Models/ViewerTypes";
+import { ModificationsState } from "../SharedDocuments/types";
+import { LocalDocumentModification } from "../SupportApi/LocalDocumentModification";
+export declare function collectModifiedFiles(documentModification: LocalDocumentModification | ModificationsState, saveSettings?: SaveSettings): string[];

package/typings/Utils/TooltipPopup.d.ts

@@ -0,0 +1,6 @@
+export declare function hideTooltipPopup(container: HTMLElement): void;
+export declare function showTooltipPopup(container: HTMLElement, message: string, theme?: {
+    textColor?: string;
+    borderColor?: string;
+    backgroundColor?: string;
+}, timeoutMs?: number): void;

package/typings/Utils/UrlUtils.d.ts

@@ -0,0 +1,17 @@
+export declare function findBaseScriptUrl(): string;
+export declare function makeAbsoluteUrl(relativeUrl: string, baseUrl?: string): string;
+export declare function getFilenameFromUrl(url: string): string;
+export declare function removeNullCharacters(str: any): any;
+export declare enum LinkTarget {
+    NONE = 0,
+    SELF = 1,
+    BLANK = 2,
+    PARENT = 3,
+    TOP = 4
+}
+export declare function addLinkAttributes(link: HTMLAnchorElement, params: {
+    url: string;
+    target: LinkTarget;
+    rel: string;
+}): void;
+export declare function createObjectURL(data: any, contentType: string, forceDataSchema?: boolean): string;

package/typings/Utils/ViewerUtils.d.ts

@@ -0,0 +1,68 @@
+import { AnnotationBase, StampAnnotation } from "../Annotations/AnnotationTypes";
+import { DataStorage } from "../DataStorage/DataStorage";
+import { SharedRef } from "./SharedRef";
+export declare function generateUid(caller?: string): string;
+export declare function updateInitialRectPosition(annotation: AnnotationBase, newXY?: number[]): void;
+export declare function resetStampAspectRatio(imageData: Uint8Array, viewer: any, pageIndex: number, originalNode: StampAnnotation, imageDpi?: number, select?: boolean): Promise<{
+    pageIndex: number;
+    annotation: AnnotationBase;
+} | null>;
+export declare function isTypedArray(arr: any): boolean;
+export declare function mergeObject(destinationObj: any, sourceVal: any, preserveNonEmpty?: boolean, copyUndefined?: boolean): any;
+export declare function cloneObject(obj: any): any;
+export declare function getTransformMatrix(viewBox: number[], rotation: number, scaleX: number, scaleY: number, ignoreRotate?: boolean): number[];
+export declare function adjustCoordinates(realViewBox: number[], point: number[], rotation: number, inverse?: boolean, fromBottomLeft?: boolean, scale?: number): number[];
+export declare function getAxialAlignedBoundingBox(r: any, m: any): number[];
+export declare function applyTransform(p: number[], m: number[]): number[];
+export declare function applyInverseTransform(p: number[], m: number[]): number[];
+export declare function inverseTransform(m: number[]): number[];
+export declare function convertToViewportPoint(x: number, y: number, transform: number[]): number[];
+export declare function convertToPdfPoint(x: number, y: number, transform: number[]): number[];
+export declare function changeRectangleOrigin(bounds: number[], viewBox: number[], destOrigin?: 'TopLeft' | 'BottomLeft', normalize?: boolean): number[];
+export declare function changeOriginToBottom(top: number, view: number[]): number;
+export declare function changeOriginToTop(bottom: number, view: number[]): number;
+export declare function pdfDateStringToDate(input?: string | Date): Date | null;
+export declare function formatRelativeDate(date: Date | null, in17n: any): any;
+export declare function humanReadableFileSize(size: number, in17n: any): string;
+export declare function getDefaultUserName(): string;
+export declare function getActiveUserName(options?: any): string;
+export declare function setActiveUserName(userName: string, setBy: 'annotation_editor' | 'user'): void;
+export declare function attachHeadJs(src: string, id?: string, ownerDoc?: ShadowRoot | Document): Promise<any>;
+export declare function stripHtmlTags(s: any): string;
+export declare function cleanseRichText(text?: string): string;
+export declare function attachHeadCss(css: any, id?: string, ownerDoc?: ShadowRoot | Document): void;
+export declare function detachHeadJs(id: string, ownerDoc?: ShadowRoot | Document): void;
+export declare function detachHeadCss(id: string, ownerDoc?: ShadowRoot | Document): void;
+export declare function moveInkLists(inkLists: {
+    x: number;
+    y: number;
+}[][], deltaX: number, deltaY: number): void;
+export declare function getAccentTextColor(): string;
+export declare function sortedIndex(array: number[], value: number): number;
+export declare function isEditorModeEnabled(container: HTMLElement): boolean;
+export declare function logMessage(msg: string): void;
+export declare function logError(msg: any): void;
+export declare function setInputCheckedState(element: HTMLInputElement, isChecked: boolean, linkService: any, fieldValue: string): void;
+export declare function updateInputCheckedAppearance(input: HTMLInputElement, isChecked?: boolean, checkedButtonValue?: string | null): void;
+export declare function updateAnnotationContentPosition(node: AnnotationBase, diffx?: number, diffy?: number): void;
+export declare function clearAnnotationRotate(contentElement: HTMLElement): void;
+export declare function applyAnnotationRotate2(contentElement: HTMLElement, data: AnnotationBase, force?: boolean): void;
+export declare function applyAnnotationRotate(contentElement: HTMLElement, data: AnnotationBase, force?: boolean): void;
+export declare function insertFirst(parent: HTMLElement, insertElem: HTMLElement): void;
+export declare function initAnnotationRotateSupport(container: HTMLElement, data: AnnotationBase, element: HTMLElement | string): void;
+export declare function calcRotationRectangles(node: AnnotationBase, rotationAngle: number, knownInitialRect?: number[]): void;
+export declare function findRotationInit(rect: number[], angleDeg: number): number[];
+export declare function updateRotationInit(annotation: AnnotationBase): void;
+export declare function isAnnotationAllowsSelectTextBehind(annotationElement?: HTMLElement | null): boolean;
+export declare function getStandardizedLanguageKey(lng: string | undefined, fallbackLng?: string | undefined): string;
+export declare function injectSerializableFile(annotation: AnnotationBase, storage: DataStorage, filePrefix?: string): void;
+export declare function generateRichMediaPoster(annotation: AnnotationBase, sharedRef: SharedRef, args?: {
+    filePropName?: "posterFile" | "file";
+    knownFileId?: string;
+    width?: number;
+    height?: number;
+    foreColor?: string;
+    backColor?: string;
+    drawBackOnly?: boolean;
+}): Promise<void>;
+export declare function setImageFileFromCanvas(canvas: HTMLCanvasElement, annotation: AnnotationBase, sharedRef: SharedRef, filePropName?: "posterFile" | "file", disposeCanvas?: boolean, knownFileId?: string | undefined): Promise<void>;

package/typings/Utils/index.d.ts

@@ -0,0 +1 @@
+export { findSelfOrAncestor, findElementIndex, getEventTarget, classListContains } from './DomUtils';

package/typings/ViewerOptions.d.ts

@@ -0,0 +1,316 @@
+import { WidgetAnnotation, GcProps, LineAnnotation, CircleAnnotation, SquareAnnotation, RedactAnnotation, TextAnnotation, InkAnnotation, PolyLineAnnotation, PolygonAnnotation, FreeTextAnnotation, FileAttachmentAnnotation, SoundAnnotation, ButtonWidget, ChoiceWidget, TextWidget, StampAnnotation, AnnotationBase, SignatureAnnotation, LinkAnnotation, PopupAnnotation, HighlightAnnotation, UnderlineAnnotation, SquigglyAnnotation, StrikeOutAnnotation, AnnotationTypeName } from "./Annotations/AnnotationTypes";
+import { RichMediaAnnotation } from "./Annotations/RichMediaAnnotation";
+import { ValidationCallerType } from "./FormFiller/types";
+import { DocumentListItem, FieldAppearanceRenderingType, JsExecutionConfig, KeyboardShortcutDefinition, OpenParameters, OptionalContentConfig, StampCategory, ViewerFeatureName } from "./Models/ViewerTypes";
+import { LogLevel } from "./SharedDocuments/types";
+import { ISupportApiBase } from "./SupportApi/ISupportApiBase";
+export type ReplyToolSettings = {
+    readOnly?: boolean;
+    allowAddNote?: boolean;
+    allowChangeUserName?: boolean;
+    allowAddReply?: boolean;
+    allowDelete?: boolean;
+    allowStatus?: boolean;
+    allowChangeOtherUser?: boolean;
+    allowDeleteOtherUser?: boolean;
+    allowStatusOtherUser?: boolean;
+    allowAddReplyOtherUser?: boolean;
+    autoExpandOnCommentAdd?: boolean;
+    annotationFocusColor?: string;
+    useColoredIcons?: boolean;
+};
+export type SupportApiSettings = {
+    apiUrl: string;
+    implementation: ISupportApiBase;
+    token?: string;
+    legacyServer?: boolean;
+    requestInit?: RequestInit;
+    webSocketUrl?: string | false;
+    reconnectInterval?: number;
+    suppressInfoMessages?: boolean;
+    suppressErrorMessages?: boolean;
+    docBaseUrl?: string;
+};
+export type TextMarkupContextMenuSettings = {
+    colors: {
+        value: string;
+        displayName: string;
+    }[] | {
+        "highlight": {
+            value: string;
+            displayName: string;
+        }[];
+        "underline": {
+            value: string;
+            displayName: string;
+        }[];
+        "strikeout": {
+            value: string;
+            displayName: string;
+        }[];
+        "squiggly": {
+            value: string;
+            displayName: string;
+        }[];
+    } | false;
+};
+export declare class ViewerOptions {
+    constructor(options?: Partial<ViewerOptions>);
+    customIcons?: {
+        [iconKey: string]: Element | string;
+    };
+    disableHistory: boolean;
+    editorDefaults: {
+        fontNames?: {
+            value: string;
+            name: string;
+        }[];
+        hideFloatingBar?: boolean;
+        rememberLastValues?: boolean;
+        lastValueKeys?: string[];
+        printResolution?: number;
+        resizeHandleSize?: number;
+        moveHandleSize?: number;
+        dotHandleSize?: number;
+        standardFontDataUrl?: string;
+        stickyNote: {
+            color?: string;
+            contents?: string;
+        };
+        lineAnnotation?: Partial<LineAnnotation>;
+        circleAnnotation?: Partial<CircleAnnotation>;
+        squareAnnotation?: Partial<SquareAnnotation>;
+        linkAnnotation?: Partial<LinkAnnotation>;
+        redactAnnotation?: Partial<RedactAnnotation>;
+        inkAnnotation?: Partial<InkAnnotation>;
+        polyLineAnnotation?: Partial<PolyLineAnnotation>;
+        polygonAnnotation?: Partial<PolygonAnnotation>;
+        textAnnotation?: Partial<TextAnnotation>;
+        freeTextAnnotation?: Partial<FreeTextAnnotation>;
+        fileAttachmentAnnotation?: Partial<FileAttachmentAnnotation>;
+        richMediaAnnotation?: Partial<RichMediaAnnotation>;
+        soundAnnotation?: Partial<SoundAnnotation>;
+        stampAnnotation?: Partial<StampAnnotation>;
+        highlightAnnotation?: Partial<HighlightAnnotation>;
+        underlineAnnotation?: Partial<UnderlineAnnotation>;
+        squigglyAnnotation?: Partial<SquigglyAnnotation>;
+        strikeOutAnnotation?: Partial<StrikeOutAnnotation>;
+        popupAnnotation?: Partial<PopupAnnotation>;
+        checkBoxButton?: Partial<ButtonWidget>;
+        radioButton?: Partial<ButtonWidget>;
+        pushButton?: Partial<ButtonWidget>;
+        resetButton?: Partial<ButtonWidget>;
+        submitButton?: Partial<ButtonWidget>;
+        comboChoice?: Partial<ChoiceWidget>;
+        listBoxChoice?: Partial<ChoiceWidget>;
+        passwordField?: Partial<TextWidget>;
+        textArea?: Partial<TextWidget>;
+        textField?: Partial<TextWidget>;
+        signatureField?: Partial<SignatureAnnotation>;
+        combTextField?: Partial<TextWidget>;
+    };
+    allowedTools: {
+        viewer?: 'all' | 'annotations' | 'fields' | string[];
+        annotationEditor?: 'all' | 'annotations' | 'fields' | string[];
+        formEditor?: 'all' | 'annotations' | 'fields' | string[];
+    };
+    fieldsAppearance: {
+        radioButton?: FieldAppearanceRenderingType;
+        checkBoxButton?: FieldAppearanceRenderingType;
+        pushButton?: FieldAppearanceRenderingType;
+    };
+    lockOpenTimeout: number;
+    snapAlignment: true | false | {
+        tolerance: number | {
+            horizontal: number | false;
+            vertical: number | false;
+        };
+        margin: false | true | number | {
+            horizontal: number | boolean;
+            vertical: number | boolean;
+        };
+        center: false | true | {
+            horizontal: boolean;
+            vertical: boolean;
+        };
+    };
+    useNativeContextMenu: boolean;
+    onBeforeOpenContextMenu?: Function;
+    onBeforeCloseContextMenu?: Function;
+    showContextMenuOnSelection?: "Auto" | "On" | "Off" | boolean;
+    textMarkupContextMenu?: TextMarkupContextMenuSettings | false;
+    optionalContentConfig?: OptionalContentConfig;
+    replyTool?: ReplyToolSettings;
+    userName?: string;
+    baseUrl?: string;
+    buttons?: string[] | "all" | 'none';
+    caret?: true | false | {
+        caretBlinkTime: number;
+        caretStopBlinkTime: number;
+        color: string;
+        width: number;
+        allowForPan: boolean;
+    };
+    sharing?: {
+        disallowUnknownUsers?: boolean;
+        knownUserNames?: string[];
+        presenceColors?: {
+            [userName: string]: string;
+        };
+        presenceMode: 'on' | 'others' | 'off' | true | false;
+    };
+    coordinatesPrecision: number;
+    coordinatesOrigin?: 'TopLeft' | 'BottomLeft';
+    disableFeatures?: ViewerFeatureName[];
+    ignoreInitialView?: boolean;
+    disablePageLabels?: boolean;
+    externalLinkTarget?: 'blank' | 'self' | 'parent' | 'top' | 'none';
+    formFiller?: FormFillerSettings;
+    jsExecutionConfig?: JsExecutionConfig;
+    pdfOrganizer?: PdfOrganizerSettings;
+    enableXfa?: boolean;
+    secondToolbar?: {
+        render?: (toolbarKey: string) => any[] | null;
+    };
+    signTool?: SignToolSettings;
+    language?: 'en' | string;
+    maxCanvasPixels?: number;
+    userData: any;
+    useFloatingSearchBar: boolean;
+    useCanvasForSelection: any;
+    renderInteractiveForms: boolean;
+    keepFileData: boolean;
+    renderer: 'canvas' | 'svg';
+    friendlyFileName?: string;
+    file?: string | any;
+    onInitialized?: (viewer: any) => void;
+    openParameters?: OpenParameters;
+    password: string;
+    supportApiPassword?: string;
+    restoreViewStateOnLoad?: false | true | {
+        trackViewMode?: boolean;
+        trackMouseMode?: boolean;
+        trackScale?: boolean;
+        trackPageRotation?: boolean;
+        trackFullScreen?: boolean;
+        trackTheme?: boolean;
+        trackSidebar?: boolean;
+        trackSidebarWidth?: boolean;
+        trackFile?: boolean;
+    };
+    documentListUrl: string | DocumentListItem[];
+    workerSrc: string;
+    zoomOptions?: {
+        minZoom?: number;
+        maxZoom?: number;
+        dropdownZoomFactorValues?: number[];
+    };
+    zoomByMouseWheel: {
+        always: boolean;
+        ctrlKey: boolean;
+        metaKey: boolean;
+    };
+    theme: string | false;
+    themes: string[];
+    requireTheme?: "light" | "dark" | "viewer" | "light-blue" | "themes/dark-yellow" | "gc-blue" | null;
+    hideAnnotationPopups?: AnnotationTypeName | 'All' | 'None' | boolean;
+    hideAnnotationTypes?: AnnotationTypeName[] | 'All' | 'None' | boolean;
+    cMapUrl?: string;
+    cMapPacked?: boolean;
+    stamp: {
+        dpi?: number;
+        stampCategories?: StampCategory[] | boolean;
+        selectedImageUrl?: string;
+    };
+    supportApi?: string | SupportApiSettings;
+    logLevel?: LogLevel;
+    shortcuts: {
+        [keyCode: string]: KeyboardShortcutDefinition | KeyboardShortcutDefinition[];
+    };
+}
+export type RulerLine = {
+    color?: string;
+    position?: number;
+    size?: number;
+    type?: 'solid' | 'dashed';
+};
+export type InputFieldMapping = {
+    hidden?: boolean;
+    nolabel?: boolean;
+    orderindex?: number;
+    rowcustomcss?: string;
+    validator?: (fieldValue: string | string[], field: WidgetAnnotation, args: {
+        caller: ValidationCallerType;
+    }) => boolean | string;
+};
+export type FormFieldMapping = InputFieldMapping & GcProps;
+export type SignToolSettings = {
+    dialogLocation?: 'Center' | 'Top' | 'Right' | 'Bottom' | 'Left' | {
+        x: number;
+        y: number;
+    };
+    hideTabs?: boolean;
+    hideToolbar?: boolean;
+    hideDialogTitle?: boolean;
+    hideSaveSignature?: boolean;
+    hideDialogFooter?: boolean;
+    tabs?: ('Type' | 'Draw' | 'Image')[];
+    selectedTab?: 'Type' | 'Draw' | 'Image';
+    title?: string;
+    penColor?: string;
+    penWidth?: number;
+    text?: string;
+    textColor?: string;
+    fontSize?: number;
+    fontName?: string;
+    fontNames?: string[];
+    italic?: boolean;
+    bold?: boolean;
+    hasImage?: boolean;
+    saveSignature?: boolean;
+    annotationType?: 'stamp' | 'signature';
+    convertToContent?: boolean;
+    subject?: string;
+    pageIndex?: number;
+    canvasSize?: {
+        width: number;
+        height: number;
+    };
+    autoResizeCanvas?: boolean;
+    location?: 'Center' | 'Top' | 'Right' | 'Bottom' | 'Left' | 'TopLeft' | 'TopRight' | 'BottomRight' | 'BottomLeft' | {
+        x: number;
+        y: number;
+    };
+    destinationScale?: number;
+    ruler?: {
+        Draw: RulerLine[] | false;
+        Type: RulerLine[] | false;
+        Image: RulerLine[] | false;
+    } | false;
+    beforeShow?: (signatureDialog: any) => boolean;
+    afterShow?: (signatureDialog: any) => void;
+    beforeAdd?: (activeTool: any, signatureDialog: any) => boolean;
+    afterAdd?: (result: {
+        pageIndex: number;
+        annotation: AnnotationBase;
+    }) => void;
+    beforeHide?: (signatureDialog: any) => boolean;
+};
+export type FormFillerSettings = {
+    applyAfterFailedValidation?: 'confirm' | 'reject' | 'apply' | Function;
+    layout?: 'Auto' | 'OneColumn' | 'TwoColumns';
+    title?: string;
+    validator?: (fieldValue: string | string[], field: WidgetAnnotation, args: {
+        caller: ValidationCallerType;
+    }) => boolean | string;
+    onInitialize?: (formFiller: any) => void;
+    beforeApplyChanges?: (formFiller: any) => boolean;
+    beforeFieldChange?: (field: WidgetAnnotation, formFiller: any) => boolean;
+    mappings: {
+        [fieldName: string]: FormFieldMapping;
+    };
+};
+export type PdfOrganizerSettings = {
+    layout?: 'Auto' | 'OneColumn' | 'TwoColumns';
+    title?: string;
+};

package/typings/XFA/XfaApiImpl.d.ts

@@ -0,0 +1,19 @@
+import GcPdfViewer from "../GcPdfViewer";
+import { XfaForm } from "./XfaForm";
+import { XfaNode } from "./XfaNode";
+export declare class XfaApiImpl {
+    viewer: GcPdfViewer;
+    private _form;
+    constructor(viewer: GcPdfViewer);
+    get host(): XfaApiImpl;
+    get form(): XfaForm;
+    get soPrintFunctions(): any;
+    resolveNode(nodeName: string): XfaNode;
+    alert(cMsg: string | any, nIcon?: number, nType?: number, cTitle?: string, oDoc?: any, oCheckbox?: any): number;
+    messageBox(cMsg: string | any, nIcon?: number, nType?: number, cTitle?: string, oDoc?: any, oCheckbox?: any): number;
+    print(): void;
+    resetData(): void;
+    setFocus(xfaNode: XfaNode): void;
+    beep(param: number): void;
+    execMenuItem(menuItem: string): Promise<any>;
+}

package/typings/XFA/XfaForm.d.ts

@@ -0,0 +1,7 @@
+import GcPdfViewer from "..";
+export declare class XfaForm {
+    viewer: GcPdfViewer;
+    constructor(viewer: GcPdfViewer);
+    recalculate: (arg: any) => {};
+    execInitialize: () => {};
+}

package/typings/XFA/XfaNode.d.ts

@@ -0,0 +1,5 @@
+export declare class XfaNode {
+    name: string;
+    rawValue: string;
+    constructor(name: string, rawValue: string);
+}

package/typings/httpClient.d.ts

@@ -0,0 +1,15 @@
+import 'whatwg-fetch';
+export type TypedResponse<T> = {
+    ok: true;
+    status: number;
+    response: T;
+} | {
+    ok: false;
+    requestError: string;
+};
+export type IHttpClient = {
+    getJson: <TR>(uri: string) => Promise<TypedResponse<TR>>;
+    postJson: <TR>(uri: string, data: unknown) => Promise<TypedResponse<TR>>;
+    getText: (uri: string) => Promise<TypedResponse<string>>;
+};
+export declare function createHttpClient(baseUri: string, authToken: string): IHttpClient;

package/typings/index.d.ts

@@ -0,0 +1,10 @@
+import 'core-js/es/set';
+import 'core-js/es/map';
+import 'core-js/web/';
+import 'blob-polyfill';
+import { GcPdfViewer } from './GcPdfViewer';
+export { GcPdfViewer };
+export { ViewerOptions } from './ViewerOptions';
+import { DsPdfViewer } from './DsPdfViewer';
+export { DsPdfViewer };
+export default GcPdfViewer;