mupdf-webviewer/types.d.ts

The web viewer SDK using mupdf.js

export function initMuPDFWebViewer(
  selector: string,
  docURL: string,
  options?: {
    licenseKey: string;
    libraryPath?: string;
    filename?: string;
    standalone?: boolean;
    withoutLoader?: boolean;
  }
): Promise<MuPDFWebViewer>;

export class MuPDFWebViewer {
  public document: {
    download(config?: {
      fileName?: string;
      includeAnnotations?: boolean;
    }): Promise<undefined>;

    getPages(config?: {
      pageRange?: string;
    }): Promise<{ pages: PageInfo[] }>;

    getPageCount(): Promise<{ pageCount: number }>;

    open(config: {
      url: string;
      filename?: string;
    }): Promise<undefined>;

    close(): Promise<undefined>;

    print(config?: {
      pageRange: string;
    }): Promise<PrintResult>;

    rotatePage(config: {
      pageRange: string;
      degree: 0 | 90 | 180 | 270 | 360;
    }): Promise<undefined>;

    getText(config?: {
      pageRange?: string;
    }): Promise<{
      pageIndex: number;
      text: string;
    }[]>;

    export(config?: {
      includeAnnotations?: boolean;
    }): Promise<Uint8Array>;
  };

  public viewer: {
    toggleDialog(config: {
      dialogType: DialogType;
      visibility?: boolean;
    }): Promise<undefined>;

    getScale(): Promise<{ scale: number }>;

    setScale(config: {
      scale: number;
    }): Promise<undefined>;

    zoomIn(config?: {
      increment?: number;
    }): Promise<undefined>;

    zoomOut(config?: {
      decrement: number;
    }): Promise<undefined>;

    getCurrentPageIndex(): Promise<{ currentPageIndex: number }>;

    getRotation(): Promise<{ degree: 0 | 90 | 180 | 270 }>;

    setRotation(config: {
      degree: 0 | 90 | 180 | 270 | 360;
    }): Promise<undefined>;

    rotateClockwise(): Promise<undefined>;

    rotateCounterClockwise(): Promise<undefined>;

    setViewMode(config: {
      viewMode: ViewMode;
    }): Promise<undefined>;

    fitTo(config: {
      to: FitMode;
    }): Promise<undefined>;

    scrollTo(config: { type: ScrollType; value: number }): Promise<undefined>
    scrollTo(config: { type: 'PAGE'; value: number; centerPoint?: { x: number; y: number } }): Promise<undefined>;
    scrollTo(config: { type: 'ANNOTATION'; value: number; select?: boolean }): Promise<undefined>;
    scrollTo(config: { type: 'ANNOTATION'; name: string; pageIndex: number; select?: boolean }): Promise<undefined>;

    scrollToNextPage(): Promise<undefined>;

    scrollToPreviousPage(): Promise<undefined>;

    selectAnnotationTool(config: AnnotationTool | AnnotationStampTool): Promise<undefined>;

    toggleAnnotationTool(config: AnnotationTool | AnnotationStampTool): Promise<undefined>;

    openSideView(config: {
      type: Panel;
    }): Promise<undefined>;

    closeSideView(config: {
      type: PanelSide;
    }): Promise<undefined>;

    togglePanel(config: {
      type: Panel;
    }): Promise<undefined>;

    highlight(config: {
      rects: HighlightRect[];
    }): Promise<HighlightedRect[]>;

    highlight(config: {
      keywords: HighlightKeyword[];
    }): Promise<HighlightedRect[]>;

    unhighlight(config: {
      rects: HighlightedRect[];
    }): Promise<undefined>;

    searchText(config: {
      keyword: string;
      caseSensitive?: boolean;
      useRegex?: boolean;
      emitEvent?: boolean;
    }): Promise<undefined>;

    setViewVisibility(config: {
      view: HidableView;
      visibility: boolean;
    }): Promise<undefined>;

    addButton(config: {
      buttons: {
        position: 'TOOLBAR.LEFT_SECTION.FIRST' | 'TOOLBAR.LEFT_SECTION.LAST';
        icon: IconName;
        label: string;
        onclick: Function;
      }[];
    }): Promise<undefined>;

    openContextMenu(): Promise<undefined>;

    addContextMenu(config: {
      menus: {
        type: 'MENU';
        position: 'FIRST' | 'LAST';
        icon?: string;
        label?: string;
        onclick?: Function;
      }[];
    }): Promise<undefined>;

    defineDocumentPanel(config: {
      items: {
        label: string;
        onclick: Function;
        icon?: string;
      }[];
    }): Promise<undefined>;

    defineAnnotSelectMenu(config: {
      html: string;
      style?: string;
      script?: string;
      tool?: AnnotType;
    }): Promise<undefined>;

    defineRightClickAction(config: {
      onclick: Function;
    }): Promise<undefined>;

    setBackgroundColor(config: {
      color: string;
    }): Promise<undefined>;

    setPageBorderColor(config: {
      color: string;
    }): Promise<undefined>;

    setColor(config: {
      mainColor: string;
      subColor: string;
    }): Promise<undefined>;

    setTheme(config: {
      type: Theme;
    }): Promise<undefined>;

    setLanguage(config: {
      key: Language;
    }): Promise<undefined>;

    getSize(): Promise<TSize>;

    setLogo(config: {
      url: string;
    }): Promise<undefined>;
  };

  public watermark: {
    create(config: {
      watermarks: (TextWatermark | ImageWatermark)[];
    }): Promise<undefined>;
  };

  public capture: {
    selectAndExport(): Promise<{ imageBytes: Uint8Array }>;
  }

  public text: {
    search(config: {
      keyword: string;
      caseSensitive?: boolean;
      useRegex?: boolean;
      pageRange?: string;
    }): Promise<{
      results: {
          words: {
            prefix: string;
            keyword: string;
            suffix: string;
            redMarked: boolean;
            rects: TRect[];
          }[];
          pageIndex: number;
      }[];
    }>;

    getSelected(): Promise<{ text: string; rects: TRect[], pageIndex: number } | undefined>;
  };

  public annotation: {
    remove(config: {
      annotations: ({
        name: string;
        pageIndex: number;
      } | {
        oid: number;
        pageIndex: number;
      })[];
      emitEvent?: boolean;
    }): Promise<undefined>;

    get(config?: {
      pageIndex: number;
    }): Promise<Annotation[]>

    add(config: {
      annotations: Annotation[];
      emitEvent?: boolean;
    }): Promise<Annotation[]>;

    set(config: {
      annotations: Annotation[];
      emitEvent?: boolean;
    }): Promise<undefined>;

    undo(): Promise<{ success: boolean }>;

    redo(): Promise<{ success: boolean }>;
  };

  public redaction: {
    get(config?: {
      textData: TextDataOption;
    }): Promise<Annotation[]>;
    
    set(config: {
      redactions: {
        oid: number;
        pageIndex: number;
        name: string;
        rect?: TRect;
        opacity?: number;
        author?: string;
        canBePrinted?: boolean;
        locked?: boolean;
      }[];
    }): Promise<undefined>;

    add(config: {
      redactions: {
        oid?: number;
        pageIndex: number;
        name?: string;
        rect: TRect;
        opacity?: number;
        author?: string;
        canBePrinted?: boolean;
        locked?: boolean;
      }[];
    }): Promise<Annotation[]>;

    remove(config: {
      redactions: {
        oid: number;
        name: string;
        pageIndex: number;
      }[];
    }): Promise<undefined>;

    apply(config: {
      redactions: {
        oid: number;
        name: string;
        pageIndex: number;
      }[];
    }): Promise<undefined>;
  }

  public toast: {
    show(config: {
      type: 'success' | 'fail' | 'notification';
      content: string;
      header?: string;
      timeout?: number;
    }): Promise<undefined>;
  };

  public addEventListener<T extends keyof EventDataMap>(
    type: T, 
    callback: (event: { type: T; data: EventDataMap[T] }) => void
  ): void;

  public refs: {
    scroll: {
      type: {
        PAGE: ScrollType.PAGE,
        ANNOTATION: ScrollType.ANNOTATION,
      },
    },
    fit: {
      to: {
        WIDTH: FitMode.WIDTH,
        HEIGHT: FitMode.HEIGHT,
        PAGE: FitMode.PAGE,
        READ: FitMode.READ,
      },
    },
    viewMode: {
      SINGLE: ViewMode.SINGLE,
      DOUBLE: ViewMode.DOUBLE,
      SINGLE_SCROLL: ViewMode.SINGLE_SCROLL,
      DOUBLE_SCROLL: ViewMode.DOUBLE_SCROLL,
      EBOOK: ViewMode.EBOOK,
    },
    degree: {
      DEG_0: Degree.DEG_0,
      DEG_90: Degree.DEG_90,
      DEG_180: Degree.DEG_180,
      DEG_270: Degree.DEG_270,
    },
    dialog: {
      type: {
        PRINT: DialogType.PRINT,
        SEARCH_TOOL: DialogType.SEARCH_TOOL,
      },
    },
    panel: {
      open: {
        THUMBNAIL: Panel.THUMBNAIL,
        BOOKMARK: Panel.BOOKMARK,
        ANNOTATION: Panel.ANNOTATION,
        REDACTION: Panel.REDACTION,
        REDACTION_SEARCHING: Panel.REDACTION_SEARCHING,
        ANNOTATION_PROPERTY: Panel.ANNOTATION_PROPERTY,
        TEXT_SEARCH: Panel.TEXT_SEARCH,
      },
      close: {
        LEFT: PanelSide.LEFT,
        RIGHT: PanelSide.RIGHT,
      },
    },
    theme: {
      DARK_MODE: Theme.DARK_MODE,
      LIGHT_MODE: Theme.LIGHT_MODE,
      SYSTEM_SYNCHRONIZATION: Theme.SYSTEM_SYNCHRONIZATION,
    },
    language: {
      KOREAN: Language.KOREAN,
      ENGLISH: Language.ENGLISH,
      JAPANESE: Language.JAPANESE,
    },
    annotation: {
      tool: {
        BUTTON: WidgetType.BUTTON,
        CHECK_BUTTON: WidgetType.CHECK_BUTTON,
        CIRCLE: AnnotType.CIRCLE,
        CLOUD: AnnotType.CLOUD,
        COMBO_BOX: WidgetType.COMBO_BOX,
        ERASER: AnnotType.ERASER,
        HIGHLIGHT: AnnotType.HIGHLIGHT,
        INK: AnnotType.INK,
        LINE: AnnotType.LINE,
        LINE_DIMENSION: AnnotType.LINE_DIMENSION,
        LINK: AnnotType.LINK,
        LIST_BOX: WidgetType.LIST_BOX,
        POLYGON: AnnotType.POLYGON,
        POLYGON_DIMENSION: AnnotType.POLYGON_DIMENSION,
        POLYLINE: AnnotType.POLYLINE,
        POLYLINE_DIMENSION: AnnotType.POLYLINE_DIMENSION,
        RADIO_BUTTON: WidgetType.RADIO_BUTTON,
        SIGNATURE: WidgetType.SIGNATURE,
        SQUARE: AnnotType.SQUARE,
        STAMP: AnnotType.STAMP,
        STRIKE: AnnotType.STRIKE,
        TEXT_CALLOUT: AnnotType.TEXT_CALLOUT,
        TEXT_FIELD: WidgetType.TEXT_FIELD,
        TEXT_FREE: AnnotType.TEXT_FREE,
        TEXT_POPUP: AnnotType.TEXT_POPUP,
        UNDERLINE: AnnotType.UNDERLINE,
      },
    },
    visibility: {
      view: {
        TOOLBAR: HidableView.TOOLBAR,
        TOOLBAR_LEFT: HidableView.TOOLBAR_LEFT,
        TOOLBAR_RIGHT: HidableView.TOOLBAR_RIGHT,
        TOOLBAR_PRINT: HidableView.TOOLBAR_PRINT,
        TOOLBAR_DOWNLOAD: HidableView.TOOLBAR_DOWNLOAD,
        TOOLBAR_VIEW_MODE: HidableView.TOOLBAR_VIEW_MODE,
        TOOLBAR_ROTATE: HidableView.TOOLBAR_ROTATE,
        TOOLBAR_ZOOM: HidableView.TOOLBAR_ZOOM,
        TOOLBAR_ANNOTATION: HidableView.TOOLBAR_ANNOTATION,
        FLOATING_NAV: HidableView.FLOATING_NAV,
        FLOATING_NAV_SEARCH: HidableView.FLOATING_NAV_SEARCH,
        ANNOTATION_STAMP: HidableView.ANNOTATION_STAMP,
        ANNOTATION_HIGHLIGHT: HidableView.ANNOTATION_HIGHLIGHT,
        ANNOTATION_STRIKE: HidableView.ANNOTATION_STRIKE,
        ANNOTATION_UNDERLINE: HidableView.ANNOTATION_UNDERLINE,
        ANNOTATION_PROPERTY_PANEL: HidableView.ANNOTATION_PROPERTY_PANEL,
        ANNOTATION_UNDO_REDO: HidableView.ANNOTATION_UNDO_REDO,
        SIDE_VIEW: HidableView.SIDE_VIEW,
        SIDE_VIEW_THUMBNAIL: HidableView.SIDE_VIEW_THUMBNAIL,
        SIDE_VIEW_BOOKMARK: HidableView.SIDE_VIEW_BOOKMARK,
        SIDE_VIEW_ANNOTATION: HidableView.SIDE_VIEW_ANNOTATION,
        CONTEXT_MENU: HidableView.CONTEXT_MENU,
        CONTEXT_MENU_HIGHLIGHT: HidableView.CONTEXT_MENU_HIGHLIGHT,
        CONTEXT_MENU_STRIKEOUT: HidableView.CONTEXT_MENU_STRIKEOUT,
        CONTEXT_MENU_UNDERLINE: HidableView.CONTEXT_MENU_UNDERLINE,
        CONTEXT_MENU_SEARCH: HidableView.CONTEXT_MENU_SEARCH,
        CONTEXT_MENU_COPY: HidableView.CONTEXT_MENU_COPY,
        INDICATOR: HidableView.INDICATOR,
        INDICATOR_SCALE: HidableView.INDICATOR_SCALE,
        INDICATOR_PAGE_NUMBER: HidableView.INDICATOR_PAGE_NUMBER,
      },
    },
    redaction: {
      textDataOption: {
        FULL: TextDataOption.FULL,
        NONE: TextDataOption.NONE,
        TEXT_ONLY: TextDataOption.TEXT_ONLY,
      },
    },
    text: {
      align: {
        LEFT: TextAlign.LEFT,
        CENTER: TextAlign.CENTER,
        RIGHT: TextAlign.RIGHT,
      },
    },
    icon: {
      SHARE: IconName.SHARE,
      PENCIL: IconName.PENCIL,
      MAIL: IconName.MAIL,
      PHONE: IconName.PHONE,
      COMMENT: IconName.COMMENT,
      PRINT: IconName.PRINT,
      MINUS: IconName.MINUS,
      PLUS: IconName.PLUS,
      CHECK_MARK: IconName.CHECK_MARK,
      SAVE: IconName.SAVE,
      DOWNLOAD: IconName.DOWNLOAD,
      SEARCH: IconName.SEARCH,
      FILLED_STAMP: IconName.FILLED_STAMP,
      PAGE: IconName.PAGE,
      TRASH_CAN: IconName.TRASH_CAN,
      SIGN_OUT: IconName.SIGN_OUT,
      BOOKMARK: IconName.BOOKMARK,
      LEFT_CHEVRON: IconName.LEFT_CHEVRON,
      DOWN_CHEVRON: IconName.DOWN_CHEVRON,
      UP_CHEVRON: IconName.UP_CHEVRON,
      RIGHT_CHEVRON: IconName.RIGHT_CHEVRON,
      CROSS: IconName.CROSS,
      CIRCLE_CHECK_MARK: IconName.CIRCLE_CHECK_MARK,
      REFRESH: IconName.REFRESH,
      NOTE: IconName.NOTE,
      SQUARE: IconName.SQUARE,
      CIRCLE: IconName.CIRCLE,
      POLYGON: IconName.POLYGON,
      TEXT_BOX: IconName.TEXT_BOX,
      TEXT_HIGHLIGHT: IconName.TEXT_HIGHLIGHT,
      TEXT_STRIKEOUT: IconName.TEXT_STRIKEOUT,
      TEXT_UNDERLINE: IconName.TEXT_UNDERLINE,
      STAMP: IconName.STAMP,
      TEXT_CURSOR: IconName.TEXT_CURSOR,
      HAND: IconName.HAND,
      EDIT: IconName.EDIT,
      PAGE_SEARCH: IconName.PAGE_SEARCH,
      CLIP: IconName.CLIP,
      PAGE_WIDTH: IconName.PAGE_WIDTH,
      PAGE_HEIGHT: IconName.PAGE_HEIGHT,
      ENTER_FULLSCREEN: IconName.ENTER_FULLSCREEN,
      EXIT_FULLSCREEN: IconName.EXIT_FULLSCREEN,
      HORIZONTAL_3DOT: IconName.HORIZONTAL_3DOT,
      FIRST: IconName.FIRST,
      LAST: IconName.LAST,
      SQUARE_PREVIOUS: IconName.SQUARE_PREVIOUS,
      SQUARE_NEXT: IconName.SQUARE_NEXT,
      CASE_SENSITIVE: IconName.CASE_SENSITIVE,
      GRID: IconName.GRID,
      LIST: IconName.LIST,
      SQUARE_CHECK_MARK: IconName.SQUARE_CHECK_MARK,
      MEMO: IconName.MEMO,
      GEAR: IconName.GEAR,
      LIST2: IconName.LIST2,
      ROUND_SQUARE_CHECK_MARK: IconName.ROUND_SQUARE_CHECK_MARK,
      FILLED_ROUND_SQUARE_CHECK_MARK: IconName.FILLED_ROUND_SQUARE_CHECK_MARK,
      IMAGE: IconName.IMAGE,
      SIGNATURE: IconName.SIGNATURE,
      USER: IconName.USER,
      MP3_FILE: IconName.MP3_FILE,
      OCR_FILE: IconName.OCR_FILE,
      TXT_FILE: IconName.TXT_FILE,
      HYPERLINK: IconName.HYPERLINK,
      COPY: IconName.COPY,
      POINTER: IconName.POINTER,
      DOUBLE_DICE: IconName.DOUBLE_DICE,
      LEFT_CHEVRON2: IconName.LEFT_CHEVRON2,
      DOWN_CHEVRON2: IconName.DOWN_CHEVRON2,
      UP_CHEVRON2: IconName.UP_CHEVRON2,
      RIGHT_CHEVRON2: IconName.RIGHT_CHEVRON2,
      LEFT_CHEVRON3: IconName.LEFT_CHEVRON3,
      DOWN_CHEVRON3: IconName.DOWN_CHEVRON3,
      UP_CHEVRON3: IconName.UP_CHEVRON3,
      RIGHT_CHEVRON3: IconName.RIGHT_CHEVRON3,
      INVISIBLE: IconName.INVISIBLE,
      VISIBLE: IconName.VISIBLE,
      COLLAPSE: IconName.COLLAPSE,
      EXPAND: IconName.EXPAND,
      TWO_WAY_VERTICAL_ARROW: IconName.TWO_WAY_VERTICAL_ARROW,
      TWO_WAY_HORIZONTAL_ARROW: IconName.TWO_WAY_HORIZONTAL_ARROW,
      PREVIOUS: IconName.PREVIOUS,
      NEXT: IconName.NEXT,
      CIRCLE_HORIZONTAL_3DOT: IconName.CIRCLE_HORIZONTAL_3DOT,
      ROTATE_COUNTER_CLOCKWISE: IconName.ROTATE_COUNTER_CLOCKWISE,
      ROTATE_CLOCKWISE: IconName.ROTATE_CLOCKWISE,
      BIDIRECTIONAL_HORIZONTAL_ARROW: IconName.BIDIRECTIONAL_HORIZONTAL_ARROW,
      MEMO2: IconName.MEMO2,
      MEDIA_PLAY: IconName.MEDIA_PLAY,
      MEDIA_NEXT: IconName.MEDIA_NEXT,
      MEDIA_FAST_FORWARD: IconName.MEDIA_FAST_FORWARD,
      MEDIA_REWIND: IconName.MEDIA_REWIND,
      MEDIA_PREVIOUS: IconName.MEDIA_PREVIOUS,
      MEDIA_PAUSE: IconName.MEDIA_PAUSE,
      MEDIA_STOP: IconName.MEDIA_STOP,
      FUNNEL: IconName.FUNNEL,
      SEND: IconName.SEND,
      CALENDAR: IconName.CALENDAR,
      UNLOCKED: IconName.UNLOCKED,
      LOCKED: IconName.LOCKED,
      UNDO: IconName.UNDO,
      REDO: IconName.REDO,
      MONITOR: IconName.MONITOR,
    },
    event: {
      type: {
        SCALE_CHANGE: EventType.SCALE_CHANGE,
        ANNOTATION_TOOL_CHANGE: EventType.ANNOTATION_TOOL_CHANGE,
        CURRENT_PAGE_INDEX_CHANGE: EventType.CURRENT_PAGE_INDEX_CHANGE,
        DOCUMENT_DOWNLOAD: EventType.DOCUMENT_DOWNLOAD,
        SIDE_VIEW_OPEN: EventType.SIDE_VIEW_OPEN,
        SIDE_VIEW_CLOSE: EventType.SIDE_VIEW_CLOSE,
        KEYDOWN: EventType.KEYDOWN,
        KEYUP: EventType.KEYUP,
        SCROLL_POSITION_CHANGE: EventType.SCROLL_POSITION_CHANGE,
        CURRENT_READING_PAGE_CHANGE: EventType.CURRENT_READING_PAGE_CHANGE,
        MOUSEDOWN: EventType.MOUSEDOWN,
        MOUSEUP: EventType.MOUSEUP,
        POINTERDOWN: EventType.POINTERDOWN,
        POINTERUP: EventType.POINTERUP,
        ANNOTATION_CREATE: EventType.ANNOTATION_CREATE,
        ANNOTATION_MODIFY: EventType.ANNOTATION_MODIFY,
        ANNOTATION_REMOVE: EventType.ANNOTATION_REMOVE,
        REDACTION_CREATE: EventType.REDACTION_CREATE,
        REDACTION_MODIFY: EventType.REDACTION_MODIFY,
        REDACTION_REMOVE: EventType.REDACTION_REMOVE,
        TEXT_SEARCH_START: EventType.TEXT_SEARCH_START,
        ACTION_HISTORY_CHANGE: EventType.ACTION_HISTORY_CHANGE,
        ANNOTATION_SELECTION_CHANGE: EventType.ANNOTATION_SELECTION_CHANGE,
        TEXT_SELECTION_CHANGE: EventType.TEXT_SELECTION_CHANGE,
      }
    }
  }
}

export enum EventType {
  SCALE_CHANGE = 'scaleChange',
  ANNOTATION_TOOL_CHANGE = 'annotationToolChange',
  CURRENT_PAGE_INDEX_CHANGE = 'currentPageIndexChange',
  DOCUMENT_DOWNLOAD = 'documentDownload',
  SIDE_VIEW_OPEN = 'sideViewOpen',
  SIDE_VIEW_CLOSE = 'sideViewClose',
  KEYDOWN = 'keydown',
  KEYUP = 'keyup',
  SCROLL_POSITION_CHANGE = 'scrollPositionChange',
  CURRENT_READING_PAGE_CHANGE = 'currentReadingPageChange',
  MOUSEDOWN = 'mousedown',
  MOUSEUP = 'mouseup',
  POINTERDOWN = 'pointerdown',
  POINTERUP = 'pointerup',
  ANNOTATION_CREATE = 'annotationCreate',
  ANNOTATION_MODIFY = 'annotationModify',
  ANNOTATION_REMOVE = 'annotationRemove',
  REDACTION_CREATE = 'redactionCreate',
  REDACTION_MODIFY = 'redactionModify',
  REDACTION_REMOVE = 'redactionRemove',
  TEXT_SEARCH_START = 'textSearchStart',
  ACTION_HISTORY_CHANGE = 'actionHistoryChange',
  ANNOTATION_SELECTION_CHANGE = 'annotationSelectionChange',
  TEXT_SELECTION_CHANGE = 'textSelectionChange'
}

export interface EventDataMap {
  [EventType.SCALE_CHANGE]: { scale: number };
  [EventType.ANNOTATION_TOOL_CHANGE]: { tool: AnnotType | WidgetType };
  [EventType.CURRENT_PAGE_INDEX_CHANGE]: { currentPageIndex: number };
  [EventType.DOCUMENT_DOWNLOAD]: {};
  [EventType.SIDE_VIEW_OPEN]: { type: PanelSide };
  [EventType.SIDE_VIEW_CLOSE]: { type: PanelSide };
  [EventType.KEYDOWN]: { event: KeyboardEvent };
  [EventType.KEYUP]: { event: KeyboardEvent };
  [EventType.SCROLL_POSITION_CHANGE]: { position: 'top' | 'bottom' | 'topover' | 'bottomover' };
  [EventType.CURRENT_READING_PAGE_CHANGE]: { pageInfo: { pageIndex: number }[] };
  [EventType.MOUSEDOWN]: { event: MouseEvent };
  [EventType.MOUSEUP]: { event: MouseEvent };
  [EventType.POINTERDOWN]: { event: PointerEvent };
  [EventType.POINTERUP]: { event: PointerEvent };
  [EventType.ANNOTATION_CREATE]: { annotation: Annotation };
  [EventType.ANNOTATION_MODIFY]: { annotation: Annotation };
  [EventType.ANNOTATION_REMOVE]: { annotation: Annotation };
  [EventType.REDACTION_CREATE]: { redaction: Annotation };
  [EventType.REDACTION_MODIFY]: { redaction: Annotation };
  [EventType.REDACTION_REMOVE]: { redaction: Annotation };
  [EventType.TEXT_SEARCH_START]: { keyword: string; caseSensitive: boolean; useRegex: boolean };
  [EventType.ACTION_HISTORY_CHANGE]: { availUndoCount: number; availRedoCount: number };
  [EventType.ANNOTATION_SELECTION_CHANGE]: { annotations: Annotation[] };
  [EventType.TEXT_SELECTION_CHANGE]: undefined;
}

export interface PageInfo {
  pageIndex: number;
  read: boolean;
  isVisible: boolean;
  bbox: BBox;
}

export type PrintResult = {
  status: 'PRINTED' | 'CANCELLED';
}

export enum DialogType {
  PRINT = 'PRINT',
  SEARCH_TOOL = 'SEARCH_TOOL',
}

export enum ViewMode {
  SINGLE = 'SINGLE',
  SINGLE_SCROLL = 'SINGLE_SCROLL',
  DOUBLE = 'DOUBLE',
  DOUBLE_SCROLL = 'DOUBLE_SCROLL',
  EBOOK = 'EBOOK',
}

export enum FitMode {
  WIDTH = 'WIDTH',
  HEIGHT = 'HEIGHT',
  PAGE = 'PAGE',
  READ = 'READ',
}

export enum ScrollType {
  PAGE = 'PAGE',
  ANNOTATION = 'ANNOTATION',
}

export enum Degree {
  DEG_0 = 0,
  DEG_90 = 90,
  DEG_180 = 180,
  DEG_270 = 270,
}

export interface AnnotationTool {
  tool: AnnotType;
  annotation?: {
    opacity?: number;
    strokeColor?: string;
    strokeWidth?: number;
    fillColor?: string;
    strokeDashPattern?: number[];
    startPointStyle?: LineEnd;
    endPointStyle?: LineEnd;
    fontColor?: string;
    fontFamily?: string;
    fontSize?: number;
  }
}

export interface AnnotationStampTool {
  tool: AnnotType;
  width?: number;
  height?: number;
}

export interface HighlightRect {
  color: string;
  pageIndex: number;
  opacity?: number;
  rect: TRect;
}

export interface HighlightKeyword {
  keyword: string;
  color: string;
  opacity?: number;
  caseSensitive?: boolean;
  useRegex?: boolean;
}

export enum Panel {
  THUMBNAIL = 'THUMBNAIL',
  BOOKMARK = 'BOOKMARK',
  ANNOTATION = 'ANNOTATION',
  REDACTION = 'REDACTION',
  REDACTION_SEARCHING = 'REDACTION_SEARCHING',
  ANNOTATION_PROPERTY = 'ANNOTATION_PROPERTY',
  TEXT_SEARCH = 'TEXT_SEARCH',
}

export enum PanelSide {
  LEFT = 'LEFT',
  RIGHT = 'RIGHT',
}

export enum Theme {
  LIGHT_MODE = 'LIGHT_MODE',
  DARK_MODE = 'DARK_MODE',
  SYSTEM_SYNCHRONIZATION = 'SYSTEM_SYNCHRONIZATION',
}

export enum WatermarkAlignment {
  CENTER = 'CENTER',
  TOP_LEFT = 'TOP_LEFT',
  TOP = 'TOP',
  TOP_RIGHT = 'TOP_RIGHT',
  LEFT = 'LEFT',
  RIGHT = 'RIGHT',
  BOTTOM_LEFT = 'BOTTOM_LEFT',
  BOTTOM = 'BOTTOM',
  BOTTOM_RIGHT = 'BOTTOM_RIGHT'
}

export enum LineEnd {
  NONE = 'NONE',
  OPENED_ARROW = 'OPENED_ARROW',
  CLOSED_ARROW = 'CLOSED_ARROW',
  R_OPENED_ARROW = 'R_OPENED_ARROW',
  R_CLOSED_ARROW = 'R_CLOSED_ARROW',
  CIRCLE = 'CIRCLE',
  DIAMOND = 'DIAMOND',
  BUTT = 'BUTT',
  SQUARE = 'SQUARE',
  SLASH = 'SLASH'
}

export enum TextAlign {
  LEFT = 'LEFT',
  CENTER = 'CENTER',
  RIGHT = 'RIGHT'
}

export enum TextDataOption {
  FULL = 'FULL',
  NONE = 'NONE',
  TEXT_ONLY = 'TEXT_ONLY',
}

export enum HidableView {
  TOOLBAR = 'TOOLBAR',
  TOOLBAR_LEFT = 'TOOLBAR.LEFT',
  TOOLBAR_ANNOTATION = 'TOOLBAR.ANNOTATION',

  TOOLBAR_RIGHT = 'TOOLBAR.RIGHT',
  TOOLBAR_VIEW_MODE = 'TOOLBAR.VIEW_MODE',
  TOOLBAR_ROTATE = 'TOOLBAR.ROTATE',
  TOOLBAR_ZOOM = 'TOOLBAR.ZOOM',
  TOOLBAR_PRINT = 'TOOLBAR.PRINT',
  TOOLBAR_DOWNLOAD = 'TOOLBAR.DOWNLOAD',

  FLOATING_NAV = 'FLOATING_NAV',
  FLOATING_NAV_SEARCH = 'FLOATING_NAV.SEARCH',

  ANNOTATION_UNDO_REDO = 'ANNOTATION.UNDO_REDO',
  ANNOTATION_TEXT_POPUP = 'ANNOTATION.TEXT_POPUP',
  ANNOTATION_STAMP = 'ANNOTATION.STAMP',
  ANNOTATION_HIGHLIGHT = 'ANNOTATION.HIGHLIGHT',
  ANNOTATION_STRIKE = 'ANNOTATION.STRIKE',
  ANNOTATION_UNDERLINE = 'ANNOTATION.UNDERLINE',
  ANNOTATION_PROPERTY_PANEL = 'ANNOTATION.PROPERTY_PANEL',

  SIDE_VIEW = 'SIDE_VIEW',
  SIDE_VIEW_THUMBNAIL = 'SIDE_VIEW.THUMBNAIL',
  SIDE_VIEW_BOOKMARK = 'SIDE_VIEW.BOOKMARK',
  SIDE_VIEW_ANNOTATION = 'SIDE_VIEW.ANNOTATION',

  CONTEXT_MENU = 'CONTEXT_MENU',
  CONTEXT_MENU_HIGHLIGHT = 'CONTEXT_MENU.HIGHLIGHT',
  CONTEXT_MENU_STRIKEOUT = 'CONTEXT_MENU.STRIKEOUT',
  CONTEXT_MENU_UNDERLINE = 'CONTEXT_MENU.UNDERLINE',
  CONTEXT_MENU_SEARCH = 'CONTEXT_MENU.SEARCH',
  CONTEXT_MENU_COPY = 'CONTEXT_MENU.COPY',

  INDICATOR = 'INDICATOR',
  INDICATOR_SCALE = 'INDICATOR.SCALE',
  INDICATOR_PAGE_NUMBER = 'INDICATOR.PAGE_NUMBER',
}

export enum AnnotType {
  INK = 'INK',
  LINE = 'LINE',
  SQUARE = 'SQUARE',
  CIRCLE = 'CIRCLE',
  POLYGON = 'POLYGON',
  POLYGON_DIMENSION = 'POLYGON_DIMENSION',
  POLYLINE = 'POLYLINE',
  POLYLINE_DIMENSION = 'POLYLINE_DIMENSION',
  CLOUD = 'CLOUD',
  TEXT_FREE = 'TEXT_FREE',
  TEXT_CALLOUT = 'TEXT_CALLOUT',
  TEXT_POPUP = 'TEXT_POPUP',
  STAMP = 'STAMP',
  LINK = 'LINK',
  HIGHLIGHT = 'HIGHLIGHT',
  STRIKE = 'STRIKE',
  UNDERLINE = 'UNDERLINE',
  REDACTION = 'REDACTION',
  ERASER = 'ERASER',
  LINE_DIMENSION = 'LINE_DIMENSION',
}

export enum WidgetType {
  TEXT_FIELD = 'TEXT_FIELD',
  COMBO_BOX = 'COMBO_BOX',
  LIST_BOX = 'LIST_BOX',
  CHECK_BUTTON = 'CHECK_BUTTON',
  RADIO_BUTTON = 'RADIO_BUTTON',
  BUTTON = 'BUTTON',
  SIGNATURE = 'SIGNATURE',
}

export interface TPoint {
  x: number;
  y: number;
}

export interface TRect {
  top: number;
  left: number;
  right: number;
  bottom: number;
}

export interface TSize {
  width: number;
  height: number;
}

export interface BBox {
  width: number;
  height: number;
  x: number;
  y: number;
}

declare const enum DestinationMode {
  XYZ = 'XYZ',
  FIT = 'Fit',
  FIT_H = 'FitH',
  FIT_V = 'FitV',
  FIT_R = 'FitR',
  FIT_B = 'FitB',
  FIT_BH = 'FitBH',
  FIT_BV = 'FitBV',
}

export interface TextWatermark {
  type: 'Text';
  opacity: number;
  align?: WatermarkAlignment;
  rotate: number;
  x: number;
  y: number;
  allowView?: boolean;
  allowPrint?: boolean;
  range?: string;
  text: string;
  size: number;
  color: string;
  fontName: string;
  bold?: boolean;
  italic?: boolean;
  border?: {
    width?: number;
    height?: number;
    color: string;
    strokeWidth: number;
    horizontalPadding?: number;
    verticalPadding?: number;
  };
  repeatHeight?: number;
  repeatWidth?: number;
}

export interface ImageWatermark {
  type: 'Image';
  opacity: number;
  align?: WatermarkAlignment;
  rotate: number;
  x: number;
  y: number;
  allowView?: boolean;
  allowPrint?: boolean;
  range?: string;
  scale: number;
  imagePath: string;
  repeatHeight?: number;
  repeatWidth?: number;
}

export interface Annotation {
  oid: number;
  type: AnnotType;
  pageIndex: number;
  name: string;
  rect: TRect;
  rects?: TRect[];
  opacity?: number;
  rotation?: number;
  createdAt?: string | null;
  modifiedAt?: string | null;
  author?: string;
  canBePrinted?: boolean;
  locked?: boolean;
  strokeColor?: string;
  strokeWidth?: number;
  imageData?: string;
  position?: TPoint;
  inkList?: TPoint[][];
  fillColor?: string;
  strokeCloudRadius?: number;
  strokeDashPattern?: number[];
  startPoint?: TPoint;
  endPoint?: TPoint;
  startPointStyle?: LineEnd;
  endPointStyle?: LineEnd;
  popupNote?: {
    oid?: number;
    rect: TRect;
    createdAt?: string | null;
    modifiedAt?: string | null;
    author?: string;
  };
  contents?: string;
  vertices?: TPoint[];
  fontColor?: string;
  textAlign?: TextAlign;
  fontFamily?: string;
  fontSize?: number;
  link?: {
    type: string;
    value: string | number;
  };
}

export enum Language {
  KOREAN = 'ko',
  ENGLISH = 'en',
  JAPANESE = 'ja'
}

export enum IconName {
  SHARE = 'SHARE',
  PENCIL = 'PENCIL',
  MAIL = 'MAIL',
  PHONE = 'PHONE',
  COMMENT = 'COMMENT',
  PRINT = 'PRINT',
  MINUS = 'MINUS',
  PLUS = 'PLUS',
  CHECK_MARK = 'CHECK_MARK',
  SAVE = 'SAVE',
  DOWNLOAD = 'DOWNLOAD',
  SEARCH = 'SEARCH',
  FILLED_STAMP = 'FILLED_STAMP',
  PAGE = 'PAGE',
  TRASH_CAN = 'TRASH_CAN',
  SIGN_OUT = 'SIGN_OUT',
  BOOKMARK = 'BOOKMARK',
  LEFT_CHEVRON = 'LEFT_CHEVRON',
  DOWN_CHEVRON = 'DOWN_CHEVRON',
  UP_CHEVRON = 'UP_CHEVRON',
  RIGHT_CHEVRON = 'RIGHT_CHEVRON',
  CROSS = 'CROSS',
  CIRCLE_CHECK_MARK = 'CIRCLE_CHECK_MARK',
  REFRESH = 'REFRESH',
  NOTE = 'NOTE',
  SQUARE = 'SQUARE',
  CIRCLE = 'CIRCLE',
  POLYGON = 'POLYGON',
  TEXT_BOX = 'TEXT_BOX',
  TEXT_HIGHLIGHT = 'TEXT_HIGHLIGHT',
  TEXT_STRIKEOUT = 'TEXT_STRIKEOUT',
  TEXT_UNDERLINE = 'TEXT_UNDERLINE',
  STAMP = 'STAMP',
  TEXT_CURSOR = 'TEXT_CURSOR',
  HAND = 'HAND',
  EDIT = 'EDIT',
  PAGE_SEARCH = 'PAGE_SEARCH',
  CLIP = 'CLIP',
  PAGE_WIDTH = 'PAGE_WIDTH',
  PAGE_HEIGHT = 'PAGE_HEIGHT',
  ENTER_FULLSCREEN = 'ENTER_FULLSCREEN',
  EXIT_FULLSCREEN = 'EXIT_FULLSCREEN',
  HORIZONTAL_3DOT = 'HORIZONTAL_3DOT',
  FIRST = 'FIRST',
  LAST = 'LAST',
  SQUARE_PREVIOUS = 'SQUARE_PREVIOUS',
  SQUARE_NEXT = 'SQUARE_NEXT',
  CASE_SENSITIVE = 'CASE_SENSITIVE',
  GRID = 'GRID',
  LIST = 'LIST',
  SQUARE_CHECK_MARK = 'SQUARE_CHECK_MARK',
  MEMO = 'MEMO',
  GEAR = 'GEAR',
  LIST2 = 'LIST2',
  ROUND_SQUARE_CHECK_MARK = 'ROUND_SQUARE_CHECK_MARK',
  FILLED_ROUND_SQUARE_CHECK_MARK = 'FILLED_ROUND_SQUARE_CHECK_MARK',
  IMAGE = 'IMAGE',
  SIGNATURE = 'SIGNATURE',
  USER = 'USER',
  MP3_FILE = 'MP3_FILE',
  OCR_FILE = 'OCR_FILE',
  TXT_FILE = 'TXT_FILE',
  HYPERLINK = 'HYPERLINK',
  COPY = 'COPY',
  POINTER = 'POINTER',
  DOUBLE_DICE = 'DOUBLE_DICE',
  LEFT_CHEVRON2 = 'LEFT_CHEVRON2',
  DOWN_CHEVRON2 = 'DOWN_CHEVRON2',
  UP_CHEVRON2 = 'UP_CHEVRON2',
  RIGHT_CHEVRON2 = 'RIGHT_CHEVRON2',
  LEFT_CHEVRON3 = 'LEFT_CHEVRON3',
  DOWN_CHEVRON3 = 'DOWN_CHEVRON3',
  UP_CHEVRON3 = 'UP_CHEVRON3',
  RIGHT_CHEVRON3 = 'RIGHT_CHEVRON3',
  INVISIBLE = 'INVISIBLE',
  VISIBLE = 'VISIBLE',
  COLLAPSE = 'COLLAPSE',
  EXPAND = 'EXPAND',
  TWO_WAY_VERTICAL_ARROW = 'TWO_WAY_VERTICAL_ARROW',
  TWO_WAY_HORIZONTAL_ARROW = 'TWO_WAY_HORIZONTAL_ARROW',
  PREVIOUS = 'PREVIOUS',
  NEXT = 'NEXT',
  CIRCLE_HORIZONTAL_3DOT = 'CIRCLE_HORIZONTAL_3DOT',
  ROTATE_COUNTER_CLOCKWISE = 'ROTATE_COUNTER_CLOCKWISE',
  ROTATE_CLOCKWISE = 'ROTATE_CLOCKWISE',
  BIDIRECTIONAL_HORIZONTAL_ARROW = 'BIDIRECTIONAL_HORIZONTAL_ARROW',
  MEMO2 = 'MEMO2',
  MEDIA_PLAY = 'MEDIA_PLAY',
  MEDIA_NEXT = 'MEDIA_NEXT',
  MEDIA_FAST_FORWARD = 'MEDIA_FAST_FORWARD',
  MEDIA_REWIND = 'MEDIA_REWIND',
  MEDIA_PREVIOUS = 'MEDIA_PREVIOUS',
  MEDIA_PAUSE = 'MEDIA_PAUSE',
  MEDIA_STOP = 'MEDIA_STOP',
  FUNNEL = 'FUNNEL',
  SEND = 'SEND',
  CALENDAR = 'CALENDAR',
  UNLOCKED = 'UNLOCKED',
  LOCKED = 'LOCKED',
  UNDO = 'UNDO',
  REDO = 'REDO',
  MONITOR = 'MONITOR',
}

export interface HighlightedRect {
  id: number;
}