/Users/ec2-user/gitlab-runner/builds/E-xKdhDoq/0/foxit/sdk/mobile/gsdk-doc-auto-build/harmony_nodejs/input/Index.js

@method Delete @description Explicitly releases the native C++ object

Remarks

This provides deterministic cleanup for native resources. When called:

• Immediately releases the C++ object (if owned)
• Invalidates the wrapper instance
• Subsequent calls to any methods will result in undefined behavior

const wrapper = new NativeObjectWrapper(...); // Use the object... wrapper.Delete(); // Explicit cleanup // wrapper is now invalid

// Start of /Users/ec2-user/gitlab-runner/builds/E-xKdhDoq/0/foxit/sdk/mobile/harmonyrdk/script/../foxit_rdk/src/main/cpp/types/libfoxit_rdk_native/actionCallback.d.ts
 
export namespace ActionCallback {
  export const e_LanguageUnknown;
  export const e_LanguageCHS;
  export const e_LanguageCHT;
  export const e_LanguageDAN;
  export const e_LanguageDEU;
  export const e_LanguageENU;
  export const e_LanguageESP;
  export const e_LanguageFRA;
  export const e_LanguageITA;
  export const e_LanguageKOR;
  export const e_LanguageJPN;
  export const e_LanguageNLD;
  export const e_LanguageNOR;
  export const e_LanguagePTB;
  export const e_LanguageSUO;
  export const e_LanguageSVE;
 
 
  export const e_AppInfoTypeFormsVersion;
  export const e_AppInfoTypeViewerType;
  export const e_AppInfoTypeViewerVariation;
  export const e_AppInfoTypeViewerVersion;
  export const e_AppInfoTypeAppVersion;
 
 
  export const e_MailTypeDoc;
  export const e_MailTypeForm;
  export const e_MailTypeMsg;
 
 
  export const e_JSFieldValueChangedByFormat;
  export const e_JSFieldValueChangedByCalculation;
  export const e_JSFieldValueChangedBySet;
 
 
  export const e_JSMediaPlayerStateOpen;
  export const e_JSMediaPlayerStateClose;
  export const e_JSMediaPlayerStatePlaying;
  export const e_JSMediaPlayerStateStop;
  export const e_JSMediaPlayerStateSuspend;
 
 
  export const e_LayoutModeSinglePage;
  export const e_LayoutModeContinuous;
  export const e_LayoutModeFacing;
  export const e_LayoutModeContinuousFacing;
 
 
  export const e_JSMailResultFailed;
  export const e_JSMailResultSuccess;
  export const e_JSMailResultUserAbort;
 
 
  export const e_SearchScopeActiveDoc;
  export const e_SearchScopeFolder;
  export const e_SearchScopeIndex;
  export const e_SearchScopeActiveIndexes;
 
 
  export const e_ModifyItemTypeNone;
  export const e_ModifyItemTypeField;
  export const e_ModifyItemTypeAnnot;
  export const e_ModifyItemTypePage;
  export const e_ModifyItemTypeDoc;
 
}
 
export class JavascriptModifyItemInfo extends NativeObjectWrapper {
  static e_JavascriptEventTypeUnknown;
  static e_JavascriptEventTypeAppInit;
  static e_JavascriptEventTypeHtmlCallback;
  static e_JavascriptEventTypeDocOpen;
  static e_JavascriptEventTypeDocWillPrint;
  static e_JavascriptEventTypeDocDidprint;
  static e_JavascriptEventTypeDocWillSave;
  static e_JavascriptEventTypeDocDidSave;
  static e_JavascriptEventTypeDocWillClose;
  static e_JavascriptEventTypePageOpen;
  static e_JavascriptEventTypePageClose;
  static e_JavascriptEventTypePageInView;
  static e_JavascriptEventTypePageOutView;
  static e_JavascriptEventTypeFieldMouseDown;
  static e_JavascriptEventTypeFieldMouseUp;
  static e_JavascriptEventTypeFieldMouseEnter;
  static e_JavascriptEventTypeFieldMouseExit;
  static e_JavascriptEventTypeFieldFocus;
  static e_JavascriptEventTypeFieldBlur;
  static e_JavascriptEventTypeFieldKeyStroke;
  static e_JavascriptEventTypeFieldValidate;
  static e_JavascriptEventTypeFieldCalculate;
  static e_JavascriptEventTypeFieldFormat;
  static e_JavascriptEventTypeScreenFocus;
  static e_JavascriptEventTypeScreenBlur;
  static e_JavascriptEventTypeScreenOpen;
  static e_JavascriptEventTypeScreenClose;
  static e_JavascriptEventTypeScreenMouseDown;
  static e_JavascriptEventTypeScreenMouseUp;
  static e_JavascriptEventTypeScreenMouseEnter;
  static e_JavascriptEventTypeScreenMouseExit;
  static e_JavascriptEventTypeScreenInview;
  static e_JavascriptEventTypeScreenOutview;
  static e_JavascriptEventTypeBatchExec;
  static e_JavascriptEventTypeMenuExec;
  static e_JavascriptEventTypeConsoleExec;
  static e_JavascriptEventTypeExternalExec;
  static e_JavascriptEventTypeBookmarkMouseUp;
  static e_JavascriptEventTypeLinkMouseUp;
  static e_JavascriptEventTypeMediaBlur;
  static e_JavascriptEventTypeMediaClose;
  static e_JavascriptEventTypeMediaDone;
  static e_JavascriptEventTypeMediaPlay;
  static e_JavascriptEventTypeMediaReady;
  static e_JavascriptEventTypeMediaSeek;
  static e_JavascriptEventTypeMediaStop;
 
  static e_JavascriptModifyItemTypeNone;
  static e_JavascriptModifyItemTypeField;
  static e_JavascriptModifyItemTypeAnnot;
  static e_JavascriptModifyItemTypePage;
  static e_JavascriptModifyItemTypeDoc;
 
  static e_JavascriptModifyPropertyTypeNone;
  static e_JavascriptModifyPropertyTypeBorderColor;
  static e_JavascriptModifyPropertyTypeFillColor;
  static e_JavascriptModifyPropertyTypeTextColor;
  static e_JavascriptModifyPropertyTypeValue;
  static e_JavascriptModifyPropertyTypeCharLimit;
  static e_JavascriptModifyPropertyTypeButtonPosition;
  static e_JavascriptModifyPropertyTypeSelectChange;
  static e_JavascriptModifyPropertyTypeAlignment;
  static e_JavascriptModifyPropertyTypeBorderStyle;
  static e_JavascriptModifyPropertyTypeButtonAlignX;
  static e_JavascriptModifyPropertyTypeButtonAlignY;
  static e_JavascriptModifyPropertyTypeButtonFitBounds;
  static e_JavascriptModifyPropertyTypeButtonScaleHow;
  static e_JavascriptModifyPropertyTypeButtonScaleWhen;
  static e_JavascriptModifyPropertyTypeComb;
  static e_JavascriptModifyPropertyTypeDefaultStyle;
  static e_JavascriptModifyPropertyTypeDefaultValue;
  static e_JavascriptModifyPropertyTypeDoNotScroll;
  static e_JavascriptModifyPropertyTypeDelay;
  static e_JavascriptModifyPropertyTypeDisplay;
  static e_JavascriptModifyPropertyTypeEditable;
  static e_JavascriptModifyPropertyTypeNotSpellCheck;
  static e_JavascriptModifyPropertyTypeHidden;
  static e_JavascriptModifyPropertyTypeHighlight;
  static e_JavascriptModifyPropertyTypeLineWidth;
  static e_JavascriptModifyPropertyTypeMultiline;
  static e_JavascriptModifyPropertyTypePassword;
  static e_JavascriptModifyPropertyTypeRect;
  static e_JavascriptModifyPropertyTypeRequired;
  static e_JavascriptModifyPropertyTypeRichText;
  static e_JavascriptModifyPropertyTypeRichValue;
  static e_JavascriptModifyPropertyTypeRotation;
  static e_JavascriptModifyPropertyTypeNormalCaption;
  static e_JavascriptModifyPropertyTypeDownCaption;
  static e_JavascriptModifyPropertyTypeRolloverCaption;
  static e_JavascriptModifyPropertyTypeTextFont;
  static e_JavascriptModifyPropertyTypeUserName;
  static e_JavascriptModifyPropertyTypeButtonSetIcon;
  static e_JavascriptModifyPropertyTypeCheckThisBox;
  static e_JavascriptModifyPropertyTypeClearItems;
  static e_JavascriptModifyPropertyTypeDefaultIsChecked;
  static e_JavascriptModifyPropertyTypeDeleteItemAt;
  static e_JavascriptModifyPropertyTypeInsertItemAt;
  static e_JavascriptModifyPropertyTypeSetItems;
  static e_JavascriptModifyPropertyTypeActivated;
  static e_JavascriptModifyPropertyTypeArrowBegin;
  static e_JavascriptModifyPropertyTypeArrowEnd;
  static e_JavascriptModifyPropertyTypeAttachIcon;
  static e_JavascriptModifyPropertyTypeBorderEffectIntensity;
  static e_JavascriptModifyPropertyTypeBorderEffectStyle;
  static e_JavascriptModifyPropertyTypeCallout;
  static e_JavascriptModifyPropertyTypeCaretSymbol;
  static e_JavascriptModifyPropertyTypeContents;
  static e_JavascriptModifyPropertyTypeDash;
  static e_JavascriptModifyPropertyTypeDoCaption;
  static e_JavascriptModifyPropertyTypeGestures;
  static e_JavascriptModifyPropertyTypeIntent;
  static e_JavascriptModifyPropertyTypeLeaderExtend;
  static e_JavascriptModifyPropertyTypeLeaderLength;
  static e_JavascriptModifyPropertyTypeLineEnding;
  static e_JavascriptModifyPropertyTypeNoteIcon;
  static e_JavascriptModifyPropertyTypeToggleNoView;
  static e_JavascriptModifyPropertyTypeOpacity;
  static e_JavascriptModifyPropertyTypePoints;
  static e_JavascriptModifyPropertyTypeQuads;
  static e_JavascriptModifyPropertyTypeTextSize;
  static e_JavascriptModifyPropertyTypeRichContents;
  static e_JavascriptModifyPropertyTypeRichDefaults;
  static e_JavascriptModifyPropertyTypeSoundIcon;
  static e_JavascriptModifyPropertyTypeSubject;
  static e_JavascriptModifyPropertyTypeVertices;
  static e_JavascriptModifyPropertyTypeImport;
  static e_JavascriptModifyPropertyTypeRemoveDataObject;
  static e_JavascriptModifyPropertyTypeImportDataObject;
  static e_JavascriptModifyPropertyTypeRemoveTemplate;
  static e_JavascriptModifyPropertyTypeAddPageTemplate;
  static e_JavascriptModifyPropertyTypeRsetForms;
  static e_JavascriptModifyPropertyTypeRsetAllForms;
  static e_JavascriptModifyPropertyTypeTitle;
  static e_JavascriptModifyPropertyTypeResizePage;
  static e_JavascriptModifyPropertyTypeSpawnPageFromTemplate;
  static e_JavascriptModifyPropertyTypeAddWeblinks;
  static e_JavascriptModifyPropertyTypeRemoveWeblinks;
  static e_JavascriptModifyPropertyTypeRemoveLinks;
  static e_JavascriptModifyPropertyTypePageRotations;
  static e_JavascriptModifyPropertyTypeNewPage;
  static e_JavascriptModifyPropertyTypeMovePage;
  static e_JavascriptModifyPropertyTypeInsertPages;
  static e_JavascriptModifyPropertyTypeReplacePages;
  static e_JavascriptModifyPropertyTypeImportAnnotFromXFDF;
  static e_JavascriptModifyPropertyTypeDeleteAnnot;
  static e_JavascriptModifyPropertyTypeAddWatermark;
  static e_JavascriptModifyPropertyTypeFlatDocument;
  static e_JavascriptModifyPropertyTypeAddFileAttachment;
  static e_JavascriptModifyPropertyTypeRuntimeHighlight;
  static e_JavascriptModifyPropertyTypeRuntimeHighlightColor;
  static e_JavascriptModifyPropertyTypeInsertFromTemplates;
  static e_JavascriptModifyPropertyTypeAddLink;
  static e_JavascriptModifyPropertyTypeMultipleSelection;
  static e_JavascriptModifyPropertyTypeSetPageTemplateVisible;
 
  static e_JavascriptModifyTypeNone;
  static e_JavascriptModifyTypeAdd;
  static e_JavascriptModifyTypeModify;
  static e_JavascriptModifyTypeDelete;
 
  constructor(r);
  constructor();
 
  constructor(event_type, page_index, field_control_index,
    modify_item_type, modify_type, modify_property_type,
    field_or_annot_name, new_value, old_value);
 
  event_type;
 
  page_index;
 
  field_control_index;
 
  modify_item_type;
 
  modify_type;
 
  modify_property_type;
 
  field_or_annot_name;
 
  new_value;
 
  old_value;
}
 
export class IActionCallback {
  Release();
 
  InvalidateRect(document, page_index, pdf_rect);
 
  GetCurrentPage(document);
 
  SetCurrentPage(document, page_index);
 
  SetCurrentPage(document, destination);
 
  GetPageRotation(document, page_index);
 
  SetPageRotation(document, page_index, rotation);
 
  ExecuteNamedAction(document, named_action);
 
  SetDocChangeMark(document, change_mark);
 
  GetDocChangeMark(document);
 
  GetOpenedDocCount();
 
  GetOpenedDoc(index);
 
  GetCurrentDoc();
 
  CreateBlankDoc();
 
  CloseDoc(document, is_prompt_to_save);
 
  OpenDoc(file_path, password);
 
  Beep(type);
 
  Response(question, title, default_value,
    label, is_password);
 
  GetFilePath(document);
 
  IsLocalFile(document);
 
  GetAttachmentsFilePath(pdf_doc, name);
 
  GetExtractedEmbeddedFilePath(pdf_doc, name);
 
  Print(document, is_ui,
    page_range, is_silent,
    is_shrunk_to_fit, is_printed_as_image,
    is_reversed, is_to_print_annots);
 
  Print(document, print_params);
 
  SubmitForm(document, form_data, length, url,
    file_format_type);
 
  LaunchURL(url);
 
  BrowseFile();
 
  BrowseFile(is_open_dialog, file_format, file_filter);
 
  GetLanguage();
 
  Alert(msg, title, type, icon);
 
  GetIdentityProperties();
 
  SetIdentityProperties(identity_properties);
 
  PopupMenu(menus, is_selected_item);
 
  PopupMenuEx(menus, is_selected_item);
 
  GetAppInfo(type);
 
  MailData(data, data_type, is_ui, to,
    subject, cc, bcc, message);
 
  VerifySignature(document, pdf_signature);
 
  GetUntitledBookmarkName();
 
  GetPrinterNameList();
 
  AddToolButton(button_item);
 
  RemoveToolButtom(button_name);
 
  GetMenuItemNameList();
 
  AddMenuItem(menu_item_config, is_prepend);
 
  AddSubMenu(menu_item_config);
 
  ShowDialog(dlg_config);
 
  GetFullScreen();
 
  SetFullScreen(is_full_screen);
 
  OnFieldValueChanged(field_name, type, value_before_changed,
    value_after_changed);
 
  UpdateLogicalLabel();
 
  MailDoc(document,
    to_address, cc_address, bcc_address,
    subject, message, is_ui);
 
  GetTemporaryFileName(document, file_suffix_name);
 
  OpenMediaPlayer(player_args);
 
  GetTemporaryDirectory();
 
  Scroll(point);
 
  SelectPageNthWord(page_index, start_offset, end_offset, is_show_selection);
 
  GetMousePosition();
 
  GetPageWindowRect();
 
  GetLayoutMode();
 
  SetLayoutMode(layout_mode, is_cover_mode);
 
  GetPageScale();
 
  SetPageScale(zoom_mode, dest);
 
  GetPageZoomMode();
 
  Query(keywords, search_scope, search_option, di_path);
 
  AddSearchIndex(di_path, is_selected);
 
  RemoveSearchIndex(search_index_config);
 
  GetSignatureAPStyleNameList();
 
  SoapRequest(request_params);
 
  EnablePageLoop(is_loop);
 
  IsPageLoop();
 
  SetDefaultPageTransitionMode(trans_type, trans_di);
 
  IsCurrentDocOpenedInBrowser();
 
  PostMessageToHtml(message);
 
  NotifyBeginDoJob(document, event_type);
 
  NotifyAfterDataChange(document, modify_item_info) ;
 
  NotifyEndDoJob(document, event_type) ;
 
  InitModifyItem(document, item_type, page_index, dict_name) ;
 
  ResetModifyItem(document) ;
 
  GetVisiblePageCount(document) ;
 
  GetVisiblePage(document, index) ;
}
 
export class MediaPlayerCallback extends NativeObjectWrapper {
  static e_JSMediaPlayerStateOpen;
  static e_JSMediaPlayerStateClose;
  static e_JSMediaPlayerStatePlaying;
  static e_JSMediaPlayerStateStop;
  static e_JSMediaPlayerStateSuspend;
 
 
  Release();
 
  Play();
 
  Close();
 
  Stop();
 
  Seek(current_pos);
 
  GetState();
 
  GetPlayerSettings();
}
 
export class MenuListArray extends NativeObjectWrapper {
  constructor(r);
  constructor();
 
  GetSize();
 
  GetAt(index);
 
  Add(element);
 
  RemoveAt(index);
 
  InsertAt(index, element);
 
  RemoveAll();
}
 
export class MenuItemExArray extends NativeObjectWrapper {
  constructor(r);
  constructor();
 
  GetSize();
 
  GetAt(index);
 
  Add(element);
 
  RemoveAt(index);
 
  InsertAt(index, element);
 
  RemoveAll();
}
 
export class MenuList extends NativeObjectWrapper {
  constructor(r);
  constructor();
 
  constructor(level, name, sub_menu_list_array);
 
  Set(level, name, sub_menu_list_array);
 
  level;
  name;
  sub_menu_list_array;
}
 
export class MenuItemEx extends NativeObjectWrapper {
  constructor(r);
  constructor();
 
  constructor(item_name, return_name, is_checked, is_enabled,
    sub_menu_item_array);
 
  Set(item_name, return_name, is_checked, is_enabled,
    sub_menu_item_array);
 
  item_name;
 
  return_name;
 
  is_checked;
 
  is_enabled;
 
  sub_menu_item_array;
}
 
export class IdentityProperties extends NativeObjectWrapper {
  constructor(r);
  constructor();
 
  constructor(corporation, email, login_name, name, first_name,
    last_name, title, department);
 
  Set(corporation, email, login_name, name, first_name,
    last_name, title, department);
 
 
  corporation;
  email;
  login_name;
  name;
  first_name;
  last_name;
  title;
  department;
}
 
export class ButtonItem extends NativeObjectWrapper {
  constructor(r);
  constructor();
 
  constructor(name, pos, exec, enable,
    marked, tooltip, label, bitmap);
 
  Set(name, pos, exec, enable,
    marked, tooltip, label, bitmap);
 
  name;
  pos;
  exec;
  enable;
  marked;
  tooltip;
  label;
  bitmap;
}
 
export class MenuItemConfig extends NativeObjectWrapper {
  constructor(r);
  constructor();
 
  constructor(name, user, parent, pos, pos_str,
    exec, enable, marked);
 
  Set(name, user, parent, pos, pos_str,
    exec, enable, marked);
 
  name;
  user;
  parent;
  pos;
  pos_str;
  exec;
  enable;
  marked;
}
 
export class DialogDescriptionElementArray extends NativeObjectWrapper {
  constructor(r);
  constructor();
 
  GetSize();
 
  GetAt(index);
 
  Add(element);
 
  RemoveAt(index);
 
  InsertAt(index, element);
 
  RemoveAll();
}
 
export class DialogDescriptionElement extends NativeObjectWrapper {
  constructor(r);
  constructor();
 
  constructor(name, item_id, type, next_tab, width, height,
    char_width, char_height,
    font, bold, italic, alignment, align_children,
    element_array);
 
  Set(name, item_id, type, next_tab, width, height,
    char_width, char_height,
    font, bold, italic, alignment, align_children,
    element_array);
 
  name;
  item_id;
  type;
  next_tab;
  width;
 
  height;
  char_width;
  char_height;
  font;
  bold;
  italic;
  alignment;
  align_children;
  element_array;
}
 
export class DialogDescriptionConfig extends NativeObjectWrapper {
  constructor(r);
  constructor();
 
  constructor(name, first_tab, width, height,
    char_width, char_height, align_children, element_array);
 
  Set(name, first_tab, width, height,
    char_width, char_height, align_children,
    element_array);
 
 
  name;
 
  first_tab;
 
  width;
 
  height;
 
  char_width;
 
  char_height;
 
  align_children;
 
  element_array;
}
 
export class SOAPAuthenticateInfo extends NativeObjectWrapper {
  constructor(r);
  constructor();
 
  constructor(username, password, is_use_platform_auth);
 
  Set(username, password, is_use_platform_auth);
 
  username;
  password;
  is_use_platform_auth;
}
 
export class SOAPRequestProperties extends NativeObjectWrapper {
  constructor(r);
  constructor();
 
  constructor(request_url, request_content, soap_action,
    soap_namespace, soap_version, content_type, is_encode,
    is_wiredump, request_header, authenticate);
 
  Set(request_url, request_content, soap_action,
    soap_namespace, soap_version, content_type, is_encode,
    is_wiredump, request_header, authenticate);
 
 
  request_url;
  request_content;
  soap_action;
  soap_namespace;
  soap_version;
  content_type;
  is_encode;
  is_wiredump;
  request_header;
  authenticate;
}
 
export class SOAPResponseInfo extends NativeObjectWrapper {
  constructor(r);
  constructor();
 
  constructor(response_header, response_body, network_error, status_code);
 
  Set(response_header, response_body, network_error, status_code);
 
  response_header;
  response_body;
  network_error;
  status_code;
}
 
export class PrintParams extends NativeObjectWrapper {
  static e_PrintContentDocument;
  static e_PrintContentDocAndAnnots;
  static e_PrintContentFormFieldsOnly;
 
 
  static e_DuplexTypeSimplex;
  static e_DuplexTypeDuplexFlipLongEdge;
  static e_DuplexTypeDuplexFlipShortEdge;
 
 
  static e_BookletDuplexModeBothSides;
  static e_BookletDuplexModeFrontSideOnly;
  static e_BookletDuplexModeBackSideOnly;
 
 
  static e_BookletBindingRight;
  static e_BookletBindingLeft;
  static e_BookletBindingLeftTall;
  static e_BookletBindingRightTall;
 
 
  static e_PageOrderHorizontal;
  static e_PageOrderHorizontalReversed;
  static e_PageOrderVertical;
 
 
  static e_PrintHandlingNone;
  static e_PrintHandlingFitPaper;
  static e_PrintHandlingReducePaper;
  static e_PrintHandlingMultiplePages;
  static e_PrintHandlingTileLargePages;
  static e_PrintHandlingBooklet;
 
 
  constructor(r);
  constructor();
 
 
  is_show_ui;
  is_reverse;
  is_print_as_image;
  is_print_auto_center;
  is_print_auto_rotate;
  is_simulate_overprinting;
  is_print_page_border;
  page_range;
  print_content;
  printer_name;
  output_file_name;
  num_copies;
  duplex_type;
  is_tile_label;
  tile_mark;
  tile_overlap;
  tile_scale
  handling;
  binding;
  booklet_duplex_mode;
  num_pages_h;
  num_pages_v;
  page_order;
}
 
export class FloatingInfo extends NativeObjectWrapper {
  static e_WindowPositionTopLeft;
  static e_WindowPositionTopCenter;
  static e_WindowPositionTopRight;
  static e_WindowPositionCenterLeft;
  static e_WindowPositionCenter;
  static e_WindowPositionCenterRight;
  static e_WindowPositionBottomLeft;
  static e_WindowPositionBottomCenter;
  static e_WindowPositionBottomRight;
 
 
  e_RelativeTargetPageWindow;
  e_RelativeTargetAppWindow;
  e_RelativeTargetDesktop;
  e_RelativeTargetMonitor;
 
 
  e_ResizeTypeNo;
  e_ResizeTypeKeepRatio;
  e_ResizeTypeYes;
 
 
  e_OffScreenAllow;
  e_OffScreenForceOnScreen;
  e_OffScreenCancel;
 
  constructor(r);
  constructor();
 
  constructor(window_pos, relative_target, resize_type,
    has_close, has_title, title, off_screen, rect);
 
  Set(window_pos, relative_target, resize_type,
    has_close, has_title, title, off_screen, rect);
 
 
  window_pos;
 
  relative_target;
 
  resize_type;
 
  has_close;
 
  has_title;
 
  title;
 
  off_screen;
 
  rect;
}
 
export class MediaSettings extends NativeObjectWrapper {
  static e_PlayerWindowTypeDockedPage;
  static e_PlayerWindowTypeFloating;
  static e_PlayerWindowTypeFullScreen;
 
 
  constructor(r);
  constructor();
 
  constructor(auto_play, base_url, bg_color, bg_opacity,
    duration, page, repeat, show_ui, is_visible, volume,
    window_type, floating_wnd_info);
 
  Set(auto_play, base_url, bg_color, bg_opacity,
    duration, page, repeat, show_ui, is_visible, volume,
    window_type, floating_wnd_info);
 
  auto_play;
 
  base_url;
 
  bg_color;
 
  bg_opacity;
 
  duration;
 
  page;
 
  repeat;
 
  show_ui;
 
  is_visible;
 
  volume;
 
  window_type;
 
  floating_wnd_info;
}
 
export class PlayerArgs extends NativeObjectWrapper {
  constructor(r);
  constructor();
 
  constructor(doc, screen_annot, rendition, URL,
    audio_format, player_settings);
 
  Set(doc, screen_annot, rendition, URL,
    audio_format, player_settings);
 
 
  doc;
 
  screen_annot;
 
  rendition;
 
  URL;
 
  audio_format;
 
  player_settings;
}
 
export class SearchOption extends NativeObjectWrapper {
  static e_WordMatchingMatchPhrase;
  static e_WordMatchingMatchAllWords;
  static e_WordMatchingMatchAnyWord;
 
 
  constructor(r);
  constructor();
 
  constructor(is_whole_word, is_case_sensitive, is_search_bookmarks,
    is_search_in_marup,
    is_search_in_attachments, is_ignore_accents, is_proximity, is_stemming,
    is_ignore_full_width,
    max_docs, word_matching, is_search_doc_text);
 
  Set(is_whole_word, is_case_sensitive, is_search_bookmarks, is_search_in_marup,
    is_search_in_attachments, is_ignore_accents, is_proximity, is_stemming,
    is_ignore_full_width,
    max_docs, word_matching, is_search_doc_text);
 
  is_whole_word;
  is_case_sensitive;
  is_search_bookmarks;
  is_search_in_markup;
  is_search_in_attachments;
  is_ignore_accents;
  is_proximity;
  is_stemming;
  is_ignore_full_width;
  max_docs;
  word_matching;
  is_search_doc_text;
}
 
export class SearchIndexConfig extends NativeObjectWrapper {
  constructor(r);
  constructor();
 
  constructor(name, is_available, path, is_selected);
 
  Set(name, is_available, path, is_selected);
 
  name;
 
  is_available;
 
  path;
 
  is_selected;
}
// End of /Users/ec2-user/gitlab-runner/builds/E-xKdhDoq/0/foxit/sdk/mobile/harmonyrdk/script/../foxit_rdk/src/main/cpp/types/libfoxit_rdk_native/actionCallback.d.ts
// Start of /Users/ec2-user/gitlab-runner/builds/E-xKdhDoq/0/foxit/sdk/mobile/harmonyrdk/script/../foxit_rdk/src/main/cpp/types/libfoxit_rdk_native/util.d.ts
export class NativeObjectReference {
  ptr;
  owned;
}
 
export abstract class NativeObjectWrapper {
  constructor(r);
 
  GetPointerAsNumber();
 
  Delete();
}
// End of /Users/ec2-user/gitlab-runner/builds/E-xKdhDoq/0/foxit/sdk/mobile/harmonyrdk/script/../foxit_rdk/src/main/cpp/types/libfoxit_rdk_native/util.d.ts
// Start of /Users/ec2-user/gitlab-runner/builds/E-xKdhDoq/0/foxit/sdk/mobile/harmonyrdk/script/../foxit_rdk/src/main/cpp/types/libfoxit_rdk_native/fdf/fdf.d.ts
 
export class FDFDoc extends NativeObjectWrapper {
  static e_FDF;
  static e_XFDF;
 
  constructor(r);
  constructor(file_read);
 
  constructor(type);
 
  constructor(path);
 
  constructor(buffer);
 
  IsEmpty();
 
  GetType();
 
  GetPDFPath();
 
  SetPDFPath(pdf_path);
 
  SaveAs(file_path);
 
 
  SaveAs(file);
 
  GetCatalog();
 
  GetFDFDict();
}
// End of /Users/ec2-user/gitlab-runner/builds/E-xKdhDoq/0/foxit/sdk/mobile/harmonyrdk/script/../foxit_rdk/src/main/cpp/types/libfoxit_rdk_native/fdf/fdf.d.ts
// Start of /Users/ec2-user/gitlab-runner/builds/E-xKdhDoq/0/foxit/sdk/mobile/harmonyrdk/script/../foxit_rdk/src/main/cpp/types/libfoxit_rdk_native/pdf/layer.d.ts
 
export class LayerNodeArray extends NativeObjectWrapper {
  constructor(r);
  constructor();
 
  GetSize();
 
  GetAt(index);
 
  Add(element);
 
  RemoveAt(index);
 
  InsertAt(index, element);
 
  RemoveAll();
}
 
export class LayerZoomData extends NativeObjectWrapper {
  constructor(r);
  constructor();
 
  constructor(min_factor, max_factor);
 
  Set(min_factor, max_factor);
 
  min_factor
  max_factor
}
 
export class LayerTree extends NativeObjectWrapper {
  static e_StateON;
  static e_StateOFF;
  static e_StateUnchanged;
  static e_StateUndefined;
 
  constructor(r);
  constructor(document);
 
  IsEmpty();
 
  SetBaseState(state);
 
  GetRootNode();
 
  GetDict();
 
  GetOCGs();
 
  GetOCGsByPageIndex(page_index);
}
 
export class LayerPrintData extends NativeObjectWrapper {
  constructor(r);
  constructor(subtype, print_state);
 
  constructor();
 
  Set(subtype, print_state);
 
  subtype;
 
  print_state;
}
 
export class LayerContext extends NativeObjectWrapper {
  static e_UsageView;
  static e_UsageDesign;
  static e_UsagePrint;
  static e_UsageExport;
  static e_UsageZoom;
 
  constructor(r);
  constructor(document, usage_type);
 
  IsEmpty();
 
  GetDocument();
 
  GetUsageType();
 
  Reset();
 
  CopyStates(source_context);
 
  MergeStates(source_context);
 
  IsVisible(layer);
 
  SetVisible(layer, is_visible);
}
 
export class LayerNode extends NativeObjectWrapper {
  IsEmpty();
 
  GetChildrenCount();
 
  GetChild(index);
 
  RemoveChild(index);
 
  MoveTo(parent_layer_node, index);
 
  AddChild(index, name, has_Layer);
 
  GetName();
 
  IsLocked();
 
  HasLayer();
 
  HasIntent(intent);
 
  IsInPage(page);
 
  GetViewUsage();
 
  GetExportUsage();
 
  GetPrintUsage();
 
  GetZoomUsage();
 
  SetName(name);
 
  SetDefaultVisible(is_visible);
 
  SetViewUsage(state);
 
  SetExportUsage(state);
 
  SetPrintUsage(data);
 
  SetZoomUsage(data);
 
  GetGraphicsObjects(page);
 
  AddGraphicsObject(page, graphicsobject);
 
  RemoveGraphicsObject(graphics_object);
 
  RemoveUsage(usage_type);
 
  GetDict();
 
  GetAnnots();
}
// End of /Users/ec2-user/gitlab-runner/builds/E-xKdhDoq/0/foxit/sdk/mobile/harmonyrdk/script/../foxit_rdk/src/main/cpp/types/libfoxit_rdk_native/pdf/layer.d.ts
// Start of /Users/ec2-user/gitlab-runner/builds/E-xKdhDoq/0/foxit/sdk/mobile/harmonyrdk/script/../foxit_rdk/src/main/cpp/types/libfoxit_rdk_native/pdf/fillsign.d.ts
 
export class TextFillSignObjectData extends NativeObjectWrapper {
  constructor(r);
  constructor(text_state, text);
 
  constructor();
 
 
  Set(text_state, text);
 
 
  text_state;
  text;
}
 
export class TextFillSignObjectDataArray extends NativeObjectWrapper {
  constructor(r);
  constructor();
 
  GetSize();
 
  GetAt(index);
 
  Add(element);
 
  RemoveAt(index);
 
  InsertAt(index, element);
 
  RemoveAll();
}
 
 
export class FillSign extends NativeObjectWrapper {
  static e_FillSignObjectTypeText;
  static e_FillSignObjectTypeCrossMark;
  static e_FillSignObjectTypeCheckMark;
  static e_FillSignObjectTypeRoundRectangle;
  static e_FillSignObjectTypeLine;
  static e_FillSignObjectTypeDot;
  static e_FillSignObjectTypeSignature;
  static e_FillSignObjectTypeInitialsSignature;
 
  constructor(r);
  constructor(page);
 
  IsEmpty();
 
  AddObject(type, point, width, height,
    rotation);
 
  AddTextObject(text_data, point, width,
    height, rotation, is_comb_field_mode);
 
  RemoveObject(fillsign_object);
 
  GetObjectAtPoint(point);
 
  GetObjectAtDevicePoint(point, matrix);
 
  GetObjectByFormXObject(formobject);
}
 
export class FillSignObject extends NativeObjectWrapper {
  constructor(r);
  constructor();
 
  IsEmpty();
 
 
  GetType();
 
  Move(point, width, height, rotation);
 
  GetRect();
 
  GenerateContent();
 
  GetFormXObject();
}
 
export class TextFillSignObject extends FillSignObject {
  constructor(r);
  constructor(fillsign_object);
 
  TextFillSignObject();
 
  GetTextDataArray();
 
  IsCombFieldMode();
}
 
export class SignatureFillSignObject extends FillSignObject {
  constructor(r);
  constructor(fillsign_object);
 
 
  IsInitialsType();
 
  SetBitmap(bitmap);
}
// End of /Users/ec2-user/gitlab-runner/builds/E-xKdhDoq/0/foxit/sdk/mobile/harmonyrdk/script/../foxit_rdk/src/main/cpp/types/libfoxit_rdk_native/pdf/fillsign.d.ts
// Start of /Users/ec2-user/gitlab-runner/builds/E-xKdhDoq/0/foxit/sdk/mobile/harmonyrdk/script/../foxit_rdk/src/main/cpp/types/libfoxit_rdk_native/pdf/filespec.d.ts
 
export class AssociatedFiles extends NativeObjectWrapper {
  static e_RelationshipUnspecified;
  static e_RelationshipSource;
  static e_RelationshipData;
  static e_RelationshipAlternative;
  static e_RelationshipSupplement;
  static e_RelationshipEncryptedPayload;
  static e_RelationshipFormData;
  static e_RelationshipSchema;
 
  constructor(r);
  constructor(pdf_doc);
 
  IsEmpty();
 
  GetAssociatedFilesCount(pdf_object);
 
  GetAssociatedFilesCount(graphics_object);
 
  GetAssociatedFile(pdf_object, index);
 
  GetAssociatedFile(graphics_object, index);
 
  AssociateFile(pdf_object, file_spec);
 
  AssociateFile(graphics_object, mark_content_item_index,
    current_resource, property_name, file_spec);
 
  AssociateFile(page, file_spec);
 
  AssociateFile(image, file_spec);
 
  AssociateFile(form_xobject, file_spec);
 
  AssociateFile(annot, file_spec);
 
  RemoveAssociatedFile(pdf_object, index);
 
  RemoveAssociatedFile(graphics_object, index);
}
 
export class FileSpec {
  constructor(document);
 
  constructor(document, pdf_object);
 
 
  IsEmpty();
 
  GetFileName();
 
  SetFileName(file_name);
 
  GetAssociteFileRelationship();
 
  SetAssociteFileRelationship(associfile_relationship);
 
  GetFileSize();
 
  GetCompressedEmbeddedFileSize();
 
  GetFileData();
 
  Embed(file_path);
 
  Embed(pdf_object);
 
  Embed(stream);
 
  IsEmbedded();
 
  GetDescription();
 
  SetDescription(description);
 
  GetCreationDateTime();
 
  SetCreationDateTime(date_time);
 
  GetModifiedDateTime();
 
  SetModifiedDateTime(date_time);
 
  GetChecksum();
 
  SetChecksum(checksum);
 
  GetSubtype();
 
  SetSubtype(subtype);
 
  GetDict();
 
  ExportToFile(path);
 
  ExportToFileStream(stream);
}
// End of /Users/ec2-user/gitlab-runner/builds/E-xKdhDoq/0/foxit/sdk/mobile/harmonyrdk/script/../foxit_rdk/src/main/cpp/types/libfoxit_rdk_native/pdf/filespec.d.ts
// Start of /Users/ec2-user/gitlab-runner/builds/E-xKdhDoq/0/foxit/sdk/mobile/harmonyrdk/script/../foxit_rdk/src/main/cpp/types/libfoxit_rdk_native/pdf/security.d.ts
 
export class SecurityHandler extends NativeObjectWrapper {
  static e_CipherNone;
  static e_CipherRC4;
  static e_CipherAES;
 
 
  constructor(r);
  constructor();
 
  IsEmpty();
 
  GetSecurityType();
}
 
export class StdEncryptData extends NativeObjectWrapper {
  constructor(r);
  constructor(is_encrypt_metadata, user_permissions, cipher, key_length);
 
  constructor();
 
  Set(is_encrypt_metadata, user_permissions, cipher, key_length);
 
  is_encrypt_metadata;
  user_permissions;
  cipher;
  key_length;
}
 
export class StdSecurityHandler extends SecurityHandler {
  static e_ModifyPermission;
  static e_ModifyUserPassword;
  static e_ModifyOwnerPassword;
 
  constructor(r);
  constructor();
 
  Initialize(encrypt_data, user_password, owner_password);
 
  InitializeW(encrypt_data, user_password, owner_password);
 
  SetAES256ModifyFlags(modify_flags);
}
 
export class CertPermission extends NativeObjectWrapper {
  static e_PrintNone;
  static e_PrintLow;
  static e_PrintHigh;
 
  static e_ChangeNone;
  static e_ChangeInsertDelRotate;
  static e_ChangeFormFill;
  static e_ChangeCommentsFormFill;
  static e_ChangeAnyExceptExtract;
 
  constructor(r);
  constructor();
 
  bEnableCopy;
  bEnableTextAccess;
  printPer;
  changePer;
}
 
export class Envelope extends NativeObjectWrapper {
  constructor(r);
 
  constructor(buffer, size);
 
  constructor(cert_file_path);
 
  constructor(cert_file_path, permission);
 
  constructor(cert_file, permission);
 
  constructor(other);
 
  GetDecryptionKey(p12_file_path, password);
}
 
export class EnvelopeArray extends NativeObjectWrapper {
  constructor(r);
  constructor();
 
  GetSize();
 
  GetAt(index);
 
  Add(element);
 
  RemoveAt(index);
 
  InsertAt(index, element);
 
  RemoveAll();
}
 
export class CertificateEncryptData extends NativeObjectWrapper {
  constructor(r);
  constructor(is_encrypt_metadata, cipher, envelopes);
 
  constructor();
 
  Set(is_encrypt_metadata, cipher, envelopes);
 
  is_encrypt_metadata;
  cipher;
  envelopes;
}
 
 
export class CertificateSecurityHandler extends SecurityHandler {
  constructor(r);
  constructor();
 
  Initialize(envelopes, cipher, is_encrypt_metadata);
 
  Initialize(encrypt_data, encrypt_key);
}
 
export class DRMEncryptData extends NativeObjectWrapper {
  constructor(r);
  constructor(is_encrypt_metadata, sub_filter, cipher,
    key_length, is_owner, user_permissions);
 
  constructor();
 
  Set(is_encrypt_metadata, sub_filter, cipher,
    key_length, is_owner, user_permissions);
 
  is_encrypt_metadata;
  sub_filter;
  cipher;
  key_length;
  is_owner;
  user_permissions;
}
 
export class DRMSecurityHandler extends SecurityHandler {
  constructor(r);
  constructor();
 
  Initialize(encrypt_data, file_id, initial_key);
 
  GetDRMValue(key);
 
  SetDRMValue(key, value);
 
  VerifyEncryptionParams();
}
 
export class CustomEncryptData extends NativeObjectWrapper {
  constructor(r);
  constructor(is_encrypt_metadata, filter, sub_filter);
 
  constructor();
 
  Set(is_encrypt_metadata, filter, sub_filter);
 
  is_encrypt_metadata;
  filter;
  sub_filter;
}
 
export class CustomSecurityHandler  extends SecurityHandler {
  constructor(r);
  constructor();
 
  Initialize(encrypt_data, callback, encrypt_info);
}
 
export class RMSEncryptData extends NativeObjectWrapper {
  constructor(r);
  constructor(is_encrypt_metadata, publish_license, server_eul_list,
    irm_version);
 
  constructor();
 
  Set(is_encrypt_metadata, publish_license, server_eul_list, irm_version);
 
 
  is_encrypt_metadata;
  publish_license;
  server_eul_list;
  irm_version;
}
 
export class RMSSecurityHandler extends SecurityHandler {
  constructor(r);
  constructor();
 
  Initialize(encrypt_data, callback);
}
 
export class ISecurityCallback {
  Release();
}
 
export class ICertificateSecurityCallback extends ISecurityCallback {
  GetDecryptionKey(envelope_buffer, envelope_length);
}
 
export class IDRMSecurityCallback extends ISecurityCallback {
  IsOwner(document, sub_filter);
 
  GetUserPermissions(document, sub_filter);
 
  GetCipherType(document, sub_filter);
 
  GetKeyLength(document, sub_filter);
 
  GetFileID(document, sub_filter);
 
  GetInitialKey(document, sub_filter);
}
 
export class ICustomSecurityCallback {
  CreateContext(filter, sub_filter, encrypt_info);
 
  ReleaseContext(context);
 
  GetUserPermissions(context, user_permission);
 
  IsOwner(context);
 
  GetCipher(context);
 
  GetEncryptKey(context);
 
  GetDecryptedSize(context, src_data_size);
 
  StartDecryptor(context, obj_num, gen_num);
 
  DecryptData(decryptor, encrypted_data, encrypted_data_len);
 
  FinishDecryptor(decryptor);
 
  GetEncryptedSize(context, obj_num, gen_num,
    src_data, src_data_len);
 
  EncryptData(context, obj_num, gen_num,
    src_data, src_data_len);
 
  UseStandardCryptoMethod(context);
 
  GetSecurityType();
}
 
export class IRMSSecurityCallback extends ICustomSecurityCallback {
}
// End of /Users/ec2-user/gitlab-runner/builds/E-xKdhDoq/0/foxit/sdk/mobile/harmonyrdk/script/../foxit_rdk/src/main/cpp/types/libfoxit_rdk_native/pdf/security.d.ts
// Start of /Users/ec2-user/gitlab-runner/builds/E-xKdhDoq/0/foxit/sdk/mobile/harmonyrdk/script/../foxit_rdk/src/main/cpp/types/libfoxit_rdk_native/pdf/pdf.d.ts
 
 
export namespace AnnotationSummaryCallback {
  export const e_AnnotationSummaryStringIDAuthor;
  export const e_AnnotationSummaryStringIDDate;
  export const e_AnnotationSummaryStringIDPage;
  export const e_AnnotationSummaryStringIDType;
  export const e_AnnotationSummaryStringIDDocumentTitle;
  export const e_AnnotationSummaryStringIDPageTitle;
  export const e_AnnotationSummaryStringIDNoAnnotations;
  export const e_AnnotationSummaryStringIDNumber;
  export const e_AnnotationSummaryStringIDSubject;
 
}
export class IAnnotationSummaryCallback {
 
  Release();
 
  GetCurrentLocaleID();
 
  GetLocalFontName();
 
  LoadString(id);
}
 
export class AnnotationSummarySettings extends NativeObjectWrapper {
  static e_SummaryLayoutSeparatePagesWithLine;
  static e_SummaryLayoutSinglePageWithLine;
  static e_SummaryLayoutAnnotationOnly;
  static e_SummaryLayoutSeparatePagesWithSequenceNumber;
  static e_SummaryLayoutSinglePageWithSequenceNumber;
 
 
  static e_TypeSortByAuthor;
  static e_TypeSortByDate;
  static e_TypeSortByPage;
  static e_TypeSortByAnnotationType;
 
 
  static e_FontSizeSmall;
  static e_FontSizeMedium;
  static e_FontSizeLarge;
 
  constructor(r);
  constructor();
 
  IsEmpty();
 
  SetSummaryLayout(type);
 
  SetSortType(type);
 
  SetFontSize(type);
 
  SetAnnotType(type, use_all);
 
  SetFileTitle(title);
 
  SetPageRect(rect);
 
  SetPageMargin(margin);
 
  SetStartPage(page_index);
 
  SetEndPage(page_index);
 
  EnableOutputNoAnnotationPage(enable);
 
  SetConnectorLineColor(color);
 
  SetConnectorLineOpacity(opacity);
 
  SetAnnotThumbnail(type, thumbnail);
}
 
export class AnnotationSummary extends NativeObjectWrapper {
  constructor(r);
  constructor(document);
 
  IsEmpty();
 
  SetCallback(callback);
 
  StartSummarize(dest_file_path, settings, pause);
 
  StartSummarize(dest_file, settings,
    pause);
}
 
export class Bookmark extends NativeObjectWrapper {
  static e_StyleNormal;
  static e_StyleItalic;
  static e_StyleBold;
 
 
  static e_PosFirstChild;
  static e_PosLastChild;
  static e_PosPrevSibling;
  static e_PosNextSibling;
  static e_PosFirstSiblingv;
  static e_PosLastSibling;
 
  constructor(r);
  constructor(pdf_doc, bookmark_dict);
 
 
  IsEmpty();
 
  GetParent();
 
  HasChild();
 
  GetFirstChild();
 
  GetNextSibling();
 
  GetDestination();
 
  SetDestination(destination);
 
  GetTitle();
 
  SetTitle(title);
 
  GetColor();
 
  SetColor(color);
 
  GetStyle();
 
  SetStyle(style);
 
  Insert(title, position);
 
  MoveTo(dest_bookmark, position);
 
  GetAction();
 
  SetAction(action);
 
  RemoveAction();
 
  IsRoot();
 
  IsFirstChild();
 
  IsLastChild();
 
  GetDict();
}
 
export class CombineDocumentInfo extends NativeObjectWrapper {
  constructor(r);
  constructor(file_path, password);
 
  CombineDocumentInfo(doc);
 
  IsEmpty();
 
  SetBookmarkTitle(bookmark_title);
 
  SetPDFFileName(pdf_file_name);
}
 
export class CombineDocumentInfoArray extends NativeObjectWrapper {
  constructor(r);
  constructor();
 
  GetSize();
 
  GetAt(index);
 
  Add(element);
 
  RemoveAt(index);
 
  InsertAt(index, element);
 
  RemoveAll();
}
 
 
export class Combination extends NativeObjectWrapper {
  static e_CombineDocsOptionBookmark;
  static e_CombineDocsOptionAcroformRename;
  static e_CombineDocsOptionStructrueTree;
  static e_CombineDocsOptionOutputIntents;
  static e_CombineDocsOptionOCProperties;
  static e_CombineDocsOptionMarkInfos;
  static e_CombineDocsOptionPageLabels;
  static e_CombineDocsOptionNames;
  static e_CombineDocsOptionObjectStream;
  static e_CombineDocsOptionDuplicateStream;
 
 
  static StartCombineDocuments(dest_file_path, document_array, options,
    pause);
 
  static StartCombineDocuments(dest_file_path, document_array, options,
    pause);
 
  static StartCombineDocuments(fdest_file, document_array,
    options, pause);
}
 
export class PageNumberRange extends NativeObjectWrapper {
  constructor(r);
  constructor(start_number, end_number, filter);
 
  constructor();
 
  Set(start_number, end_number, filter);
 
  start_number;
  end_number;
  filter;
}
 
export class HeaderFooterContent extends NativeObjectWrapper {
  constructor(r);
  constructor(header_left_content, header_center_content,
    header_right_content, footer_left_content,
    footer_center_content, footer_right_content);
 
  constructor();
 
 
  Set(header_left_content, header_center_content,
    header_right_content, footer_left_content,
    footer_center_content, footer_right_content);
 
 
  header_left_content;
  header_center_content;
  header_right_content;
  footer_left_content;
  footer_center_content;
  footer_right_content;
}
 
export class HeaderFooter extends NativeObjectWrapper {
  constructor(r);
  constructor(font, text_size, text_color, page_range, page_margin,
    has_text_shrinked, has_fixedsize_for_print, start_page_number,
    content, is_to_embed_font, is_underline);
 
 
  constructor();
 
  Set(font, text_size, text_color, page_range, page_margin,
    has_text_shrinked, has_fixedsize_for_print, start_page_number,
    content, is_to_embed_font, is_underline);
 
 
  font;
 
  text_size;
 
  text_color;
 
  page_range;
 
  page_margin;
 
  has_text_shrinked;
 
  has_fixedsize_for_print;
 
  start_page_number;
 
  content;
 
  is_to_embed_font;
 
  is_underline;
 
  is_replace_font;
}
 
export class HeaderFooterContentGenerator extends NativeObjectWrapper {
  static e_DateFormatMSlashD;
  static e_DateFormatMSlashDSlashYY;
  static e_DateFormatMSlashDSlashYYYY;
  static e_DateFormatMMSlashDDSlashYY;
  static e_DateFormatMMSlashDDSlashYYYY;
  static e_DateFormatDSlashMSlashYY;
  static e_DateFormatDSlashMSlashYYYY;
  static e_DateFormatDDSlashMMSlashYY;
  static e_DateFormatDDSlashMMSlashYYYY;
  static e_DateFormatMMSlashYY;
  static e_DateFormatMMSlashYYYY;
  static e_DateFormatMDotDDotYY;
  static e_DateFormatMDotDDotYYYY;
  static e_DateFormatMMDotDDDotYY;
  static e_DateFormatMMDotDDDotYYYY;
  static e_DateFormatMMDotYY;
  static e_DateFormatDDotMDotYYYY;
  static e_DateFormatDDDotMMDotYY;
  static e_DateFormatDDDotMMDotYYYY;
  static e_DateFormatYYHyphenMMHyphenDD;
  static e_DateFormatYYYYHyphenMMHyphenDD;
 
  static e_PageNumberFormatDefault;
  static e_PageNumberFormatNumberOfCount;
  static e_PageNumberFormatNumberSlashCount;
  static e_PageNumberFormatPageNumber;
  static e_PageNumberFormatPageNumberOfCount;
 
  constructor(r);
  constructor();
 
  IsEmpty();
 
  AddDate(format_type);
 
  AddPageNumber(format_type);
 
  AddString(new_string);
 
  Clear();
 
  GenerateContent();
}
 
 
export class OutputPreview extends NativeObjectWrapper {
  static e_ShowAll;
  static e_ShowDeviceCMYK;
  static e_ShowNotDeviceCMYK;
  static e_ShowICCBasedCMYK;
  static e_ShowSpotColor;
  static e_ShowDeviceCMYKAndSpot;
  static e_ShowNotDeviceCMYKOrSpot;
  static e_ShowDeviceN;
  static e_ShowCMYK;
  static e_ShowRGB;
  static e_ShowDeviceRGB;
  static e_ShowICCBasedRGB;
  static e_ShowGray;
  static e_ShowDeviceGray;
  static e_ShowCalGray;
  static e_ShowCalibrated;
  static e_ShowLab;
  static e_ShowDevice;
  static e_ShowImages;
  static e_ShowSolidColor;
  static e_ShowSmoothShades;
  static e_ShowRegistrationColor;
  static e_ShowText;
  static e_ShowLineArt;
 
 
  static e_ColorantTypeProcess;
  static e_ColorantTypeSpot;
 
  constructor(r);
  constructor(pdf_doc);
 
  IsEmpty();
 
  SetSimulationProfile(icc_profile_path);
 
  SetShowType(show_type);
 
  GetPlates(colorant_type);
 
  GetSpotPlateColor(plate_name);
 
  SetCheckStatus(plate_name, to_check);
 
  IsChecked(plate_name);
 
  EnableSimulateOverprint(is_to_simulate_overprint);
 
  GeneratePreviewBitmap(page, matrix, renderer);
}
 
 
export class Attachments extends NativeObjectWrapper {
  constructor(r);
  constructor(doc, nametree);
 
  IsEmpty();
 
  GetCount();
 
  GetKey(index);
 
  GetEmbeddedFile(key);
 
  SetEmbeddedFile(key, file_spec);
 
  AddEmbeddedFile(key, file_spec);
 
  AddFromFilePath(key, file_path);
 
  RemoveEmbeddedFile(key);
 
  RemoveAllEmbeddedFiles();
 
  ExtractEmbeddedFileTo(key, dst_file_path);
 
  GetNameTree();
}
 
export class TiledWatermarkSettings extends NativeObjectWrapper {
 
  static e_FlagAsPageContents;
  static e_FlagAsAnnot;
  static e_FlagOnTop;
  static e_FlagNoPrint;
  static e_FlagInvisible;
 
  constructor(r);
 
  constructor(row_space, col_space, rotation, opacity, scale, flags);
 
  constructor();
 
  Set(row_space, col_space, rotation, opacity, scale, flags);
 
  row_space;
  col_space;
  rotation;
  opacity;
  scale;
  flags;
}
 
export class WrapperData extends NativeObjectWrapper {
  constructor(r);
  constructor();
 
  constructor(version, type, app_id, uri, description);
 
  Set(version, type, app_id, uri, description);
 
  version;
  type;
  app_id;
  uri;
  description;
}
 
export class PayLoadData extends NativeObjectWrapper {
  constructor(r);
  constructor();
 
  constructor(version, crypto_filter, file_name,
    file_size, description);
 
  Set(version, crypto_filter, file_name,
    file_size, description);
 
 
  version;
  crypto_filter;
  file_name;
  file_size;
  description;
}
 
export class PageBasicInfo extends NativeObjectWrapper {
  constructor(r);
  constructor(width, height, rotation);
 
  constructor();
 
 
  Set(width, height, rotation);
 
  width;
 
  height;
  rotation;
}
 
export class EmbeddedFontData extends NativeObjectWrapper {
  constructor(r);
  constructor();
 
  nonstandard_font_name_array;
  standard_font_name_array;
}
 
export class TableOfContentsConfig extends NativeObjectWrapper {
  constructor(r);
  constructor(title, bookmark_level_array, is_show_serial_number,
    include_toc_pages);
 
  constructor()
 
 
  
  Set(title, bookmark_level_array, is_show_serial_number,
    include_toc_pages);
 
 
  title;
  bookmark_level_array;
  is_show_serial_number;
  include_toc_pages;
}
 
export class PDFDoc extends NativeObjectWrapper {
  static e_PwdInvalid;
  static e_PwdNoPassword;
  static e_PwdUser;
  static e_PwdOwner;
 
 
  static e_EncryptUnknown;
  static e_EncryptNone;
  static e_EncryptPassword;
  static e_EncryptCertificate;
  static e_EncryptFoxitDRM;
  static e_EncryptCustom;
  static e_EncryptRMS;
  static e_EncryptCDRM;
 
 
  static e_PermPrint;
  static e_PermModify;
  static e_PermExtract;
  static e_PermAnnotForm;
  static e_PermFillForm;
  static e_PermExtractAccess;
  static e_PermAssemble;
  static e_PermPrintHigh;
 
 
  static e_SaveFlagNormal;
  static e_SaveFlagIncremental;
  static e_SaveFlagNoOriginal;
  static e_SaveFlagXRefStream;
  static e_SaveFlagLinearized;
  static e_SaveFlagRemoveRedundantObjects;
  static e_SaveFlagNoUpdatingMetadataDateTime;
 
 
  static e_ImportFlagNormal;
  static e_ImportFlagWithLayers;
  static e_ImportFlagShareStream;
 
 
  static e_ExtractPagesOptionAnnotation;
  static e_ExtractPagesOptionStructureTree;
  static e_ExtractPagesOptionJavascript;
  static e_ExtractPagesOptionOCProperties;
  static e_ExtractPagesOptionObjectStream;
  static e_ExtractPagesOptionAttachFiles;
  static e_ExtractPagesOptionBookmark;
  static e_ExtractPagesOptionSignature;
 
  static e_InsertDocOptionAttachments;
  static e_InsertDocOptionBookmark;
 
  static e_DisplayUseNone;
  static e_DisplayUseOutlines;
  static e_DisplayUseThumbs;
  static e_DisplayFullScreen;
  static e_DisplayUseOC;
  static e_DisplayUseAttachment;
 
 
  static e_Forms;
  static e_Annots;
  static e_Links;
 
 
  static e_WrapperNone;
  static e_WrapperFoxit;
  static e_WrapperPDFV2;
 
  constructor(r);
  constructor();
 
  constructor(path);
 
  constructor(buffer);
 
  constructor(file_read, is_async);
 
  IsEmpty();
 
  GetFileSize();
 
  EnableInitializingJavascript(to_initialize_js);
 
  IsLinearized();
 
  IsTaggedPDF();
 
  Load(password);
 
  LoadW(password);
 
  StartLoad(password, is_cache_stream,
    pause);
 
  StartLoadW(password, is_cache_stream,
    pause);
 
  GetFirstAvailPageIndex();
 
  IsXFA();
 
  IsEncrypted();
 
  ClearRenderCache();
 
  GetPasswordType();
 
  GetEncryptionType();
 
  CheckPassword(password);
 
  IsUserPassword(password);
 
 
  IsOwnerPassword(password);
 
 
  GetUserPassword(owner_password);
 
  GetStdEncryptData();
 
  GetCertificateEncryptData();
 
  GetDRMEncryptData();
 
  GetCustomEncryptData();
 
  GetRMSEncryptData();
 
  SaveAs(file_path, save_flags);
  SaveAsAsync(file_path, save_flags);<boolean>;
 
  StartSaveAs(file_path, save_flags,
    pause);
  StartSaveAsAsync(file_path, save_flags,
    pause);<Progressive>;
 
 
  StartSaveAs(file, save_flags,
    pause);
 
  GetRootBookmark();
 
  CreateRootBookmark();
 
  GetBookmarkLevelDepth();
 
  RemoveBookmark(bookmark);
 
  HasLayer();
 
  HasHeaderFooter();
 
  GetEditableHeaderFooter();
 
  AddHeaderFooter(headerfooter);
 
  UpdateHeaderFooter(headerfooter);
 
  RemoveAllHeaderFooters();
 
  GetPageCount();
 
  GetPage(index);
 
  GetPageAsync(index);<PDFPage>;
 
  GetDisplayMode();
 
  SetDisplayMode(display_mode);
 
  GetCatalog();
 
  GetTrailer();
 
  GetInfo();
 
  GetEncryptDict();
 
  GetPagesDict();
 
  GetIndirectObject(object_number);
 
  AddIndirectObject(pdf_object);
 
  DeleteIndirectObject(object_number);
 
  GetUserPermissions();
 
  IsWrapper();
 
  GetWrapperType();
 
  GetWrapperData();
 
  GetWrapperOffset();
 
  GetPayLoadData();
 
  StartGetPayloadFile(payload_file, pause);
 
  SaveAsWrapperFile(file_path, wrapper_data,
    user_permissions, owner_password);
 
  StartSaveAsPayloadFile(file_path, payload_file_path,
    crypto_filter, description, version,
    ave_flags, pause);
 
  HasForm();
 
  GetReadingBookmarkCount();
 
  GetReadingBookmark(index);
 
  InsertReadingBookmark(reading_bookmark_index, title, dest_page_index);
 
  RemoveReadingBookmark(reading_bookmark);
 
  GetSignatureCount();
 
  GetSignature(index);
 
  RemoveSignature(signature);
 
 
  InsertPage(index, width, height);
 
  InsertPage(index, size);
 
  AddPageFromTemplate(template_name);
 
  HidePageTemplate(template_name);
 
  RemovePage(index);
 
  RemovePage(page);
 
  MovePageTo(page, dest_index);
 
  MovePagesTo(page_range, dest_index);
 
  StartImportPagesFromFilePath(dest_index, src_file_path, password,
    flags, layer_name, page_range,
    pause);
 
  StartImportPagesFromFilePathAsync(dest_index, src_file_path, password,
    flags, layer_name, page_range,
    pause);<Progressive>;
 
  StartImportPages(dest_index, src_doc,
    flags, layer_name, page_range,
    pause);
 
  StartImportPagesAsync(dest_index, src_doc,
    flags, layer_name, page_range,
    pause);<Progressive>;
 
  StartExtractPages(file_path, options, page_range,
    pause);
 
  StartExtractPagesAsync(file_path, options, page_range,
    pause);<Progressive>;
 
  StartExtractPages(file, options, page_range,
    pause);
 
 
  InsertDocument(dest_index, src_doc, options);
 
  InsertDocument(dest_index, src_doc, options, bookmark_title);
 
  Sanitize();
 
  RemoveHiddenInfo(hidden_data_setting);
 
  ImportFromFDF(fdf_doc, types, page_range);
 
  ImportFromFDFAsync(fdf_doc, types, page_range);<boolean>;
 
  ImportAnnotFromFDF(fdf_doc, source_fdf_page_index, dest_pdf_page_index);
 
  ExportToFDF(fdf_doc, types, page_range);
 
  ExportToFDFAsync(fdf_doc, types, page_range);<boolean>;
 
  ExportAnnotToFDF(pdf_annot, fdf_doc);
 
  ExportFormFieldsToFDF(field_array, is_include, fdf_doc);
 
  GetHeader();
 
  GetFileVersion();
 
  SetFileVersion(version);
 
  SetSecurityHandler(handler);
 
  GetSecurityHandler();
 
  RemoveSecurity();
 
  GetFontCount();
 
  GetFont(index);
 
  GetOpenAction();
 
  SetOpenAction(action);
 
  RemoveOpenAction();
 
  DoJSOpenAction();
 
  IsPortfolio();
 
  GetPageBasicInfo(index);
 
  getAllPageBasicInfo();
 
  GetPageBasicInfoAsync(index);<PageBasicInfo>;
 
  GetEmbeddedFontData();
 
 
  CreateDSS();
 
  AddTableOfContents(title, bookmark_level_array);
 
  AddTableOfContents(table_of_contents_config);
 
  SetCacheFile(file_stream, is_own_file_stream);
 
  StartRecognizeForm(pause);
 
  StartRecognizeForm(is_set_tool_tips, pause);
 
  GetPageText(page_index);
 
  AddPagingSealSignature(page_range, width, height,
    to_check_permission);
 
  StartEmbedAllFonts(pause);
 
  StartAddTiledWatermark(text, settings, properties, page_range,
    pause);
 
  StartAddTiledWatermark(src_img_file_path, settings, page_range,
    pause);
 
  StartAddTiledWatermark(src_img_stream, settings, page_range,
    pause);
 
  StartAddTiledWatermark(page, settings, page_range,
    pause);
 
  GetAnnotsByIdArray(unique_id_arr);
 
  RemoveStructTree();
 
  LoadAnnotsFonts(page_range);
}
 
export class DocViewerPrefs extends NativeObjectWrapper {
  static e_PrintScaleNone;
  static e_PrintScaleAppDefault;
 
 
  static e_HideToolbar;
  static e_HideMenubar;
  static e_HideWindowUI;
  static e_FitWindow;
  static e_CenterWindow;
  static e_DisplayDocTitle;
 
  constructor(r);
  constructor(document, pdf_dict);
 
  IsEmpty();
 
  GetUIDisplayStatus(pref);
 
  SetUIDisplayStatus(pref, value);
 
  GetNonFullScreenPageMode();
 
  SetNonFullScreenPageMode(display_mode);
 
  GetReadingDirection();
 
  SetReadingDirection(is_left_to_right);
 
  GetViewArea();
 
  SetViewArea(box_type);
 
  GetViewClip();
 
  SetViewClip(box_type);
 
  GetPrintArea();
 
  SetPrintArea(box_type);
 
  GetPrintClip();
 
  SetPrintClip(box_type);
 
  GetPrintScale();
 
  SetPrintScale(print_scale);
 
  GetPrintCopies();
 
  SetPrintCopies(print_copies);
 
  GetPrintRange();
 
  SetPrintRange(page_range);
 
  GetDict();
}
 
 
export class Metadata extends NativeObjectWrapper {
  constructor(r);
  constructor(document);
 
  IsEmpty();
 
  HasKey(key);
 
  GetCreationDateTime();
 
  GetModifiedDateTime();
 
  SetCreationDateTime(date_time);
 
  SetModifiedDateTime(date_time);
 
  GetValues(key);
 
  SetValues(key, value_array);
 
  GetCustomerKeys();
 
  RemoveCustomerKey(key);
}
 
export class GraphicsObjects extends NativeObjectWrapper {
  static e_TextMergeNone;
  static e_TextMergeTJY;
  static e_TextMergeBTET;
 
  IsEmpty();
 
  GetFirstGraphicsObjectPosition(filter);
 
  GetNextGraphicsObjectPosition(position, filter);
 
  GetLastGraphicsObjectPosition(filter);
 
  GetPrevGraphicsObjectPosition(position, filter);
 
  GetGraphicsObject(position);
 
  InsertGraphicsObject(position_insert_after, graphics_object);
 
  RemoveGraphicsObject(graphics_object);
 
  RemoveGraphicsObjectByPosition(position);
 
  MoveGraphicsObjectByPosition(current_position, position_move_after);
 
  GetGraphicsObjectPosition(graphics_object);
 
  GetGraphicsObjectCount();
 
  GetGraphicsObjectIndex(graphics_object);
 
  GetGraphicsObject(index);
 
  GenerateContent();
  GenerateContentAsync();<boolean>;
 
  GenerateContent(text_merge_option);
  GenerateContentAsync(text_merge_option);<boolean>;
 
  Release();
}
 
export class PDFPage extends GraphicsObjects {
  static e_ParsePageNormal;
  static e_ParsePageTextOnly;
 
 
  static e_CalcContentsBox;
  static e_CalcDetection;
 
 
  static e_FlattenAll;
  static e_FlattenNoAnnot;
  static e_FlattenNoFormControl;
 
 
  static e_MediaBox;
  static e_CropBox;
  static e_TrimBox;
  static e_ArtBox;
  static e_BleedBox;
 
 
  static e_SizeLetter;
  static e_SizeLegal;
  static e_SizeA2;
  static e_SizeA3;
  static e_SizeA4;
  static e_SizeA5;
  static e_SizeA6;
  static e_SizeB2;
  static e_SizeB3;
  static e_SizeB4;
  static e_SizeB5;
  static e_SizeB6;
 
  constructor(r);
  constructor(document, page_dict);
 
  GetDocument();
 
  GetDict();
 
  IsParsed();
 
  StartParse(flags, pause,
    is_reparse);
 
  StartParseAsync(flags, pause,
    is_reparse);<Progressive>;
 
  GetIndex();
 
  GetHeight();
 
  GetWidth();
 
  GetRotation();
 
  LoadThumbnail();
 
  GetDisplayMatrix(left, top, width, height, rotate);
 
  CalcContentBBox(mode);
 
  GetAnnotCount();
 
  GetAnnot(index);
  GetAnnotAsync(index);<Annot>;
 
  GetAnnotAtPoint(position, tolerance);
 
  GetAnnotAtDevicePoint(position, tolerance, matrix);
 
  GetAnnotsAtPoint(position, tolerance);
 
  GetAnnotsAtDevicePoint(position, tolerance, matrix);
 
  AddAnnot(type, rect);
 
  AddAnnotAsync(type, rect);<Annot>;
 
  AddAnnot(annot_dict);
 
  RemoveAnnot(annot);
 
  MoveAnnotToFirst(annot);
 
  MoveAnnotToLast(annot);
 
  MoveAnnotToPrev(annot);
 
  MoveAnnotToNext(annot);
 
  UpdateAnnotList();
 
  HasTransparency();
 
  IsScanned();
 
  Flatten(for_display, options);
 
  FlattenAnnot(annot);
 
  SetAnnotGroup(annot_array, header_index);
 
  AddSignature(rect);
 
  AddSignature(rect, field_name);
 
  AddSignature(rect, field_name, signature_type, to_check_permission);
 
  AddSignatureWithExistedVDict(rect, field_name, signature_type, to_check_permission,
    existed_signature);
 
 
  HasWatermark();
 
  RemoveAllWatermarks();
 
  SetRotation(rotate);
 
  SetSize(width, height);
 
  SetSize(size);
 
  SetBox(box_type, box);
 
  GetBox(box_type);
 
  GetUserUnitSize();
 
  SetUserUnitSize(user_unit);
 
  Transform(matrix, need_transform_clip_path, need_transform_annotations);
 
  Normalize();
 
  SetClipRect(clip_rect);
 
  SetThumbnail(thumbnail);
 
  GetGraphicsObjectAtPoint(point, tolerance,
    filter);
 
  GetGraphicsObjectsAtPoint(point, tolerance, filter);
 
  GetGraphicsObjectAtDevicePoint(point, tolerance, matrix,
    filter);
 
  GetGraphicsObjectsAtDevicePoint(point, tolerance, matrix,
    filter);
 
  GetGraphicsObjectAtRectangle(rect, filter);
 
  GetGraphicsObjectsAtRectangle(rect, filter);
 
  AddImage(image, frame_index, position, width, height,
    auto_generate_content);
 
  AddImageFromFilePath(file_path, position, width, height,
    auto_generate_content);
 
  GetAnnots();
 
  GetResources();
 
  GetContents();
 
  GetThumb();
 
  GetInheritedAttribute(attruibute_name);
 
  ClearRenderCache();
 
  GetSuggestedRect(render_result, render_matrix, point);
 
  AddText(text, rect, style, matrix, is_each_text,
    disable_embed_font);
 
  AddText(text, rect, style, rotation, rotate_point,
    disable_embed_font);
 
  CalculateNewRectForText(text, rect, style, rotation, rotate_point,
    disable_embed_font);
 
  SplitTextsInRectangle(rect, split_step);
}
 
export class PageLabels extends NativeObjectWrapper {
  static e_None
  static e_DecimalNums
  static e_UpperRomanNums
  static e_LowerRomanNums
  static e_UpperLetters
  static e_LowerLetters
 
  constructor(r);
  constructor(document);
 
  IsEmpty();
 
  GetPageLabelTitle(page_index);
 
  HasPageLabel(page_index);
 
  GetPageLabelStyle(page_index);
 
  GetPageLabelPrefix(page_index);
 
  GetPageLabelStart(page_index);
 
  SetPageLabel(page_index, label_style, first_label_number, prefix_string);
 
  RemovePageLabel(page_index);
 
  RemoveAll();
 
  GetNumberTree();
}
 
export class PortfolioNode extends NativeObjectWrapper {
  static e_TypeUnknown;
  static e_TypeFolder;
  static e_TypeFile;
 
  IsEmpty();
 
  GetNodeType();
}
 
export class PortfolioNodeArray extends NativeObjectWrapper {
  constructor(r);
  constructor();
 
  GetSize();
 
  GetAt(index);
 
  Add(element);
 
  RemoveAt(index);
 
  InsertAt(index, element);
 
  RemoveAll();
}
 
export class PortfolioFolderNode extends NativeObjectWrapper {
  IsRoot();
 
  GetName();
 
  AddFile(file_path);
 
  AddFile(file_stream, file_name);
 
  AddPDFDoc(pdf_doc, file_name);
 
  AddSubFolder(folder_name);
 
  RemoveSubNode(sub_node);
 
  GetSortedSubNodes();
 
  GetModifiedDateTime();
 
  GetCreationDateTime();
 
  GetDescription();
 
  SetDescription(description);
}
 
export class PortfolioFileNode extends PortfolioNode {
  GetFileSpec();
 
  GetKeyName();
}
 
export class SchemaField extends NativeObjectWrapper {
  constructor(r);
  constructor();
 
  IsEmpty();
 
  GetKeyName();
 
  SetKeyName(key_name);
 
  GetSubtypeName();
 
  SetSubtypeName(subtype_name);
 
  GetDisplayName();
 
  SetDisplayName(display_name);
 
  IsVisible();
 
  SetVisibility(is_visible);
}
 
export class SchemaFieldArray extends NativeObjectWrapper {
  constructor(r);
  constructor();
 
  GetSize();
 
  GetAt(index);
 
  Add(element);
 
  RemoveAt(index);
 
  InsertAt(index, element);
 
  RemoveAll();
}
 
 
export class Portfolio extends NativeObjectWrapper {
  static e_InitialViewUnknownMode;
  static e_InitialViewDetailMode;
  static e_InitialViewTileMode;
  static e_InitialViewHidden;
 
 
  static CreatePortfolio();
 
  static CreatePortfolio(portfolio_pdf_doc);
 
  IsEmpty();
 
  GetPortfolioPDFDoc();
 
  GetRootNode();
 
  GetInitialViewMode();
 
  SetInitialViewMode(mode);
 
  IsSortedInAscending();
 
  SetSortingOrder(use_ascending_order);
 
  GetSortingFieldKeyName();
 
  SetSortingFieldKeyName(name);
 
  GetInitialFileSpecKeyName();
 
  SetInitialFileSpecKeyName(name);
 
  GetSchemaFields();
 
  SetSchemaFields(field_array);
}
 
export class ReadingBookmark extends NativeObjectWrapper {
  IsEmpty();
 
  GetTitle();
 
  SetTitle(title);
 
  GetPageIndex();
 
  SetPageIndex(index);
 
  GetDateTime(is_creation_date);
 
  SetDateTime(date_time, is_creation_date);
}
 
export class ReflowPage extends NativeObjectWrapper {
  static e_Normal;
  static e_WithImage;
  static e_NoTruncate;
 
  constructor(r);
  constructor(page);
 
  IsEmpty();
 
  SetScreenSize(width, height);
 
  SetScreenMargin(left, top, right, bottom);
 
  SetZoom(zoom);
 
  SetParseFlags(flags);
 
  SetLineSpace(line_space);
 
  SetImageScale(image_scale);
 
  SetTopSpace(top_space);
 
  StartParse(pause);
  StartParseAsync(pause);<Progressive>;
 
  GetContentWidth();
 
  GetContentHeight();
 
  GetDisplayMatrix(offset_x, offset_y, width, height, rotate);
 
  GetFocusData(matrix, point);
 
  GetFocusPosition(matrix, focus_data);
 
  IsParsed();
}
 
export class Rendition extends NativeObjectWrapper {
  static e_MediaOptionMustBeHonored;
  static e_MediaOptionBestEffort;
 
 
  static e_MediaPermTempNever;
  static e_MediaPermTempExtract;
  static e_MediaPermTempAccess;
  static e_MediaPermTempAlways;
 
 
  static e_MediaPlayerMustUsed;
  static e_MediaPlayerAvailable;
  static e_MediaPlayerNotUsed;
 
 
  static e_MediaPlayerFitStyleMeet;
  static e_MediaPlayerFitStyleSlice;
  static e_MediaPlayerFitStyleFill;
  static e_MediaPlayerFitStyleScroll;
  static e_MediaPlayerFitStyleHidden;
  static e_MediaPlayerFitStyleDefault;
 
 
  static e_WindowTypeFloating;
  static e_WindowTypeFullScreen;
  static e_WindowTypeHidden;
  static e_WindowTypeAnnotRect;
 
 
  static e_MonitorSpecifierLargest;
  static e_MonitorSpecifierSmallest;
  static e_MonitorSpecifierPrimary;
  static e_MonitorSpecifierGreatestColorDepth;
  static e_MonitorSpecifierGreatestArea;
  static e_MonitorSpecifierGreatestHeight;
  static e_MonitorSpecifierGreatestWidth;
 
 
  static e_FloatingWindowRelatedWindowDocument;
  static e_FloatingWindowRelatedWindowApplication;
  static e_FloatingWindowRelatedWindowFullDesktop;
  static e_FloatingWindowRelatedWindowMonitor;
 
 
  static e_FloatingWindowResizeTypeNo;
  static e_FloatingWindowResizeTypeAspectRatio;
  static e_FloatingWindowResizeTypeAnyway;
 
 
  static e_FloatingWindowOffscreenEventNone;
  static e_FloatingWindowOffscreenEventMoveResize;
  static e_FloatingWindowOffscreenEventNonViable;
 
  constructor(r);
  constructor(pdf_doc, rendition_dict);
 
  IsEmpty();
 
  GetDict();
 
  GetRenditionName();
 
  SetRenditionName(name);
 
  HasMediaClip();
 
  GetMediaClipName();
 
  SetMediaClipName(name);
 
  GetMediaClipFile();
 
  SetMediaClipFile(file_specification);
 
  GetMediaClipContentType();
 
  SetMediaClipContentType(content_type);
 
  GetPermission();
 
  SetPermission(permission);
 
  GetMediaDescriptions();
 
  SetMediaDescriptions(description_array);
 
  GetMediaBaseURL();
 
  SetMediaBaseURL(base_url, opt_type);
 
  GetMediaPlayerCount(type);
 
  GetMediaPlayer(type, index);
 
  AddMediaPlayer(type, player);
 
  RemoveMediaPlayer(type, player);
 
  GetVolume();
 
  SetVolume(volume, opt_type);
 
  IsControlBarVisible();
 
  EnableControlBarVisible(is_visible, opt_type);
 
  GetFitStyle();
 
  SetFitStyle(fit_style, opt_type);
 
  GetDuration();
 
  SetDuration(duration, opt_type);
 
  IsAutoPlay();
 
  EnableAutoPlay(is_auto_play, opt_type);
 
  GetRepeatCount();
 
  SetRepeatCount(count, opt_type);
 
  GetWindowType();
 
  SetWindowType(window_type, opt_type);
 
  GetBackgroundColor();
 
  SetBackgroundColor(color, opt_type);
 
  GetBackgroundOpacity();
 
  SetBackgroundOpacity(opacity, opt_type);
 
  GetMonitorSpecifier();
 
  SetMonitorSpecifier(monitor_specifier, opt_type);
 
  GetFloatingWindowWidth();
 
  GetFloatingWindowHeight();
 
  SetFloatingWindowSize(width, height, opt_type);
 
  GetFloatingWindowRelatedWindowType();
 
  SetFloatingWindowRelatedWindowType(window_type, opt_type);
 
  GetFloatingWindowPosition();
 
  SetFloatingWindowPosition(position, opt_type);
 
  GetFloatingWindowOffscreenEvent();
 
  SetFloatingWindowOffscreenEvent(offscreen_event, opt_type);
 
  HasFloatingWindowTitleBar();
 
  EnableFloatingWindowTitleBar(is_visible, opt_type);
 
  HasFloatingWindowCloseButton();
 
  EnableFloatingWindowCloseButton(is_visible, opt_type);
 
  GetFloatingWindowResizeType();
 
  SetFloatingWindowResizeType(resize_type, opt_type);
 
  GetFloatingWindowTitles();
 
  SetFloatingWindowTitles(titles, opt_type);
}
 
export class MediaPlayer extends NativeObjectWrapper {
  constructor(r);
  constructor(media_player_dict);
 
  IsEmpty();
 
  GetDict();
 
  GetSoftwareURI();
 
  SetSoftwareURI(uri);
 
  GetOSIdentifiers();
 
  SetOSIdentifiers(identifier_array);
}
 
export class ISearchCancelCallback {
  NeedToCancelNow();
}
 
export class TextPageCharInfo extends NativeObjectWrapper {
  static e_Unknown;
  static e_Normal;
  static e_Generated;
  static e_UnUnicode;
  static e_Hyphen;
  static e_ComboWord;
 
  constructor(r);
  constructor(font, flag, font_size, origin_x, origin_y,
    char_box, char_outbox, matrix);
 
  constructor();
 
  Set(font, flag, font_size, origin_x, origin_y,
    char_box, char_outbox, matrix);
 
 
  font;
 
  flag;
 
  font_size;
 
  origin_x;
 
  origin_y;
 
  char_box;
 
  char_outbox;
 
  matrix;
}
 
export class TextPage extends NativeObjectWrapper {
  static e_ParseTextNormal;
  static e_ParseTextOutputHyphen;
  static e_ParseTextUseStreamOrder;
 
 
  e_TextStreamOrder;
  e_TextDisplayOrder;
 
  constructor(r);
  constructor(page, flags);
 
  IsEmpty();
 
  GetCharCount();
 
  GetCharInfo(char_index);
 
  GetChars(start, count);
 
  GetIndexAtPos(x, y, tolerance);
 
  GetTextInRect(rect);
 
  GetText(flag);
 
  GetWordAtPos(x, y, tolerance);
 
  GetTextRectCount(start, count);
 
  GetTextRect(rect_index);
 
  GetBaselineRotation(rect_index);
 
  GetTextRectArrayByRect(rect);
 
  GetCharRange(rect);
 
  GetTextUnderAnnot(annot);
}
 
export class TextSearch extends NativeObjectWrapper {
  static e_SearchNormal;
  static e_SearchMatchCase;
  static e_SearchMatchWholeWord;
  static e_SearchConsecutive;
  static e_SearchNotMatchFullWidth;
 
  constructor(r);
  constructor(document, cancel, flags);
 
 
  constructor(xfa_document, cancel);
 
  TextSearch(text_page);
 
  TextSearch(annot);
 
  IsEmpty();
 
  SetPattern(key_words);
 
  SetStartPage(page_index);
 
  SetEndPage(page_index);
 
  SetStartCharacter(char_index);
 
  SetSearchFlags(search_flags);
 
  FindNext();
 
  FindPrev();
 
  GetMatchRects();
 
  GetMatchPageIndex();
 
  GetMatchSentence();
 
  GetMatchSentenceStartIndex();
 
  GetMatchSentenceEndIndex();
 
  GetMatchStartCharIndex();
 
  GetMatchEndCharIndex();
}
 
export class TextLink extends NativeObjectWrapper {
  IsEmpty();
 
  GetURI();
 
  GetStartCharIndex();
 
  GetEndCharIndex();
 
  GetRects();
}
 
export class PageTextLinks extends NativeObjectWrapper {
  constructor(r);
  constructor(page);
 
  IsEmpty();
 
  GetTextLinkCount();
 
  GetTextLink(index);
}
 
 
export class SnappedPoint extends NativeObjectWrapper {
  static e_TypeNone;
  static e_TypeEndpoint;
  static e_TypeMidpoint;
  static e_TypeIntersectionPoint;
  static e_TypeNearestPoint;
 
  IsEmpty();
 
  GetType();
 
  GetPoint();
}
 
export class SnapPointMgr extends NativeObjectWrapper {
  static e_FlagEndpoint;
  static e_FlagMidpoint;
  static e_FlagIntersectionPoint;
  static e_FlagNearestPoint;
 
  constructor(r);
  constructor(page);
 
  IsEmpty();
 
  Reload();
 
  GetSnappedPointAtPos(position, flags);
}
 
export class TabOrderMgr extends NativeObjectWrapper {
  static e_None;
  static e_Row;
  static e_Column;
  static e_Structure;
 
  constructor(r);
  constructor(page);
 
  IsEmpty();
 
  Reload();
 
  GetOrderType();
 
  SetOrderType(order_type);
 
  GetFirstAnnot();
 
  GetLastAnnot();
 
  GetNextAnnot(annot);
 
  GetPrevAnnot(annot);
 
  AdjustStructureOrder(annot_array);
}
 
export class HiddenInfoSettingData extends NativeObjectWrapper {
  constructor();
 
  enable_remove_metadata;
 
  enable_remove_fileattachment;
 
  enable_remove_bookmark;
 
  enable_remove_searchIndex;
 
  enable_remove_comment;
 
  enable_remove_form_fields;
 
  enable_remove_hidden_text;
 
  enable_remove_hidden_layer;
 
  enable_remove_content;
 
  enable_remove_link;
 
  enable_remove_overlaping;
}
 
export class PageBasicInfoArray extends NativeObjectWrapper {
  constructor();
 
  constructor(other);
 
  GetSize();
 
  GetAt(index);
 
  Add(element);
 
  RemoveAt(index);
 
  InsertAt(index, newElement);
 
  RemoveAll();
}
// End of /Users/ec2-user/gitlab-runner/builds/E-xKdhDoq/0/foxit/sdk/mobile/harmonyrdk/script/../foxit_rdk/src/main/cpp/types/libfoxit_rdk_native/pdf/pdf.d.ts
// Start of /Users/ec2-user/gitlab-runner/builds/E-xKdhDoq/0/foxit/sdk/mobile/harmonyrdk/script/../foxit_rdk/src/main/cpp/types/libfoxit_rdk_native/pdf/psi.d.ts
 
export class IPSICallback {
  Release();
 
  Refresh(psi, rect);
}
 
export class PSI extends NativeObjectWrapper {
  constructor(r);
  constructor(bitmap, simulate);
 
  constructor(width, height, simulate);
 
  IsEmpty();
 
  SetCallback(callback);
 
  SetColor(color);
 
  SetDiameter(diameter);
 
  SetOpacity(opacity);
 
  AddPoint(point, type, pressure);
 
  GetContentsRect();
 
  GetBitmap();
 
  ConvertToPDFAnnot(page, annot_rect, rotate);
}
// End of /Users/ec2-user/gitlab-runner/builds/E-xKdhDoq/0/foxit/sdk/mobile/harmonyrdk/script/../foxit_rdk/src/main/cpp/types/libfoxit_rdk_native/pdf/psi.d.ts
// Start of /Users/ec2-user/gitlab-runner/builds/E-xKdhDoq/0/foxit/sdk/mobile/harmonyrdk/script/../foxit_rdk/src/main/cpp/types/libfoxit_rdk_native/pdf/watermark.d.ts
 
export class Watermark extends NativeObjectWrapper {
  constructor(r);
  constructor(document, text, properties, settings);
 
  constructor(document, bitmap, settings);
 
  constructor(document, image, frame_index, settings);
 
  constructor(document, page, settings);
 
  IsEmpty();
 
  GetWidth();
 
  GetHeight();
 
  InsertToPage(page);
}
 
export class WatermarkSettings extends NativeObjectWrapper {
  static e_FlagASPageContents;
  static e_FlagASAnnot;
  static e_FlagOnTop;
  static e_FlagNoPrint;
  static e_FlagInvisible;
  static e_FlagShareImageStream;
  static e_FlagShareTextStream;
  static e_FlagSharePageStream;
 
  constructor(r);
  constructor(position, offset_x, offset_y, flags,
    scale_x, scale_y, rotation, opacity);
 
  constructor();
 
  Set(position, offset_x, offset_y, flags,
    scale_x, scale_y, rotation, opacity);
 
  position;
  offset_x;
  offset_y;
  flags;
  scale_x;
  scale_y;
  rotation;
  opacity;
}
 
export class WatermarkTextProperties extends NativeObjectWrapper {
  static e_FontStyleNormal;
  static e_FontStyleUnderline;
 
  constructor(r);
  constructor(font, font_size, color, style, line_space, alignment);
 
 
  constructor();
 
  Set(font, font_size, color, style, line_space, alignment);
 
 
  font;
  font_size;
  color;
  font_style;
  line_space;
  alignment;
}
// End of /Users/ec2-user/gitlab-runner/builds/E-xKdhDoq/0/foxit/sdk/mobile/harmonyrdk/script/../foxit_rdk/src/main/cpp/types/libfoxit_rdk_native/pdf/watermark.d.ts
// Start of /Users/ec2-user/gitlab-runner/builds/E-xKdhDoq/0/foxit/sdk/mobile/harmonyrdk/script/../foxit_rdk/src/main/cpp/types/libfoxit_rdk_native/pdf/ltvverifier.d.ts
 
export class Response extends NativeObjectWrapper {
  static e_TypeNone;
  static e_TypeCRL;
  static e_TypeOCSP;
 
  constructor(r);
  constructor(type, response_data);
 
  constructor();
 
  Set(type, response_data);
 
  type;
  response_data;
}
 
export class TimeRange extends NativeObjectWrapper {
  constructor(r);
  constructor(start_time, end_time);
 
  constructor();
 
  Set(start_time, end_time);
 
  start_time;
  end_time;
}
 
export class CertVerifyResult extends NativeObjectWrapper {
  static e_CertStatusValid;
  static e_CertStatusRevoked;
  static e_CertStatusExpired;
  static e_CertStatusUnknown;
 
 
  static e_ReasonNoStatus;
  static e_ReasonUnspecified;
  static e_ReasonKeyCompromise;
  static e_ReasonCACompromise;
  static e_ReasonAffiliationChanged;
  static e_ReasonSuperseded;
  static e_ReasonCessationOfOperation;
  static e_ReasonCertificateHold;
  static e_ReasonRemoveFromCRL;
  static e_ReasonPrivilegeWithDrawn;
  static e_ReasonAACompromise;
 
 
  static e_LocationNotSet;
  static e_LocationDSS;
  static e_LocationSignature;
  static e_LocationOnline;
 
  constructor(r);
  constructor(cert, is_ca, is_trusted, response,
    response_effect_time_range, revoke_time,
    cert_status, reason,
    cert_check_time,
    exist_signature_vri_creation_time, signature_vri_creation_time,
    exist_response_signature_vri_creation_time, response_signature_vri_creation_time,
    response_info_location);
 
  constructor();
 
  Set(cert, is_ca, is_trusted, response,
    response_effect_time_range, revoke_time,
    cert_status, reason,
    cert_check_time,
    exist_signature_vri_creation_time, signature_vri_creation_time,
    exist_response_signature_vri_creation_time, response_signature_vri_creation_time,
    response_info_location);
 
  cert;
 
  is_ca;
  is_trusted;
  response;
  response_effect_time_range;
  revoke_time;
  cert_status;
  reason;
  cert_check_time;
  exist_signature_vri_creation_time;
  signature_vri_creation_time;
  exist_response_signature_vri_creation_time;
  response_signature_vri_creation_time;
  response_info_location;
}
 
export class CertVerifyResultArray extends NativeObjectWrapper {
  constructor(r);
  constructor();
 
  GetSize();
 
  GetAt(index);
 
  Add(element);
 
  RemoveAt(index);
 
  InsertAt(index, element);
 
  RemoveAll();
}
 
 
export class CertIssuerPair extends NativeObjectWrapper {
  constructor(r);
  constructor(cert, issuer);
 
  constructor();
 
 
  Set(cert, issuer);
 
 
  cert;
  issuer;
}
 
 
export class RevocationArrayInfo extends NativeObjectWrapper {
  constructor(r);
  constructor(ocsp_array, crl_array);
 
  constructor();
 
 
  Set(ocsp_array, crl_array);
 
  ocsp_array;
  crl_array;
}
 
export class IRevocationCallback {
  Release();
 
  GetCertChainFromSignature(signature_content);
 
  GetResponseOnLineForSingleCert(cert_issuer_pair);
 
  VerifyOCSP(cert_issuer_pair, ocsp_data);
 
  VerifyCRL(cert_issuer_pair, crl_data);
 
  IsCA(cert);
 
  GetDTSTime(signature_content);
 
  GetTSTSignature(signature_content);
 
  GetTSTTime(signature_content);
 
  GetOCSPCertAndIssuer(ocsp_data, trust_cert_chain);
 
  GetOCSPProducedAtTime(ocsp_data);
 
  IsOCSPNeedCheck(ocsp_data);
 
  GetCertValidTimeRange(cert);
 
  GetOCSPSignature(ocsp_data);
 
  GetCRLSignature(crl_data);
 
  GetRevocationInfoFromSignatureData(signature_content);
 
  IsIssuerMatchCert(cert_issuer_pair);
}
 
export class ITrustedCertStoreCallback {
  IsCertTrusted(cert);
 
  IsCertTrustedRoot(cert);
}
 
export class ICertChainResolverCallback {
  GetCertificates();
}
 
 
export class LTVVerifier extends NativeObjectWrapper {
  static e_SignatureCreationTime;
  static e_SignatureTSTTime;
  static e_CurrentTime;
  static e_VRICreationTime;
 
 
  static e_VerifyModeAcrobat;
 
  constructor(r);
  constructor(document, is_verify_signature, use_expired_tst,
    ignore_doc_info, time_type);
 
  IsEmpty();
 
  SetRevocationCallback(callback);
 
  SetVerifyMode(mode);
 
  SetTrustedCertStoreCallback(callback);
 
  SetCertChainResolverCallback(callback);
 
  Verify();
 
  VerifySignature(signature);
  VerifySignatureAsync(signature);<SignatureVerifyResultArray>;
 
  AddDSS(signature_verify_result);
}
 
export class SignatureVerifyResult extends NativeObjectWrapper {
  static e_LTVStateInactive;
  static e_LTVStateEnable;
  static e_LTVStateNotEnable;
 
  IsEmpty();
 
  GetSignatureName();
 
  GetSignatureHashValue();
 
  GetSignatureState();
 
  GetSignatureCheckTime();
 
  GetSignatureCheckTimeType();
 
  GetLTVState();
 
  GetCertificateVerifyResults();
 
  GetOCSPSigantureVerifyResults();
 
  GetTSTSignatureVerifyResult();
}
 
export class SignatureVerifyResultArray extends NativeObjectWrapper {
  constructor(r);
  constructor();
 
  GetSize();
 
  GetAt(index);
 
  Add(element);
 
  RemoveAt(index);
 
  InsertAt(index, element);
 
  RemoveAll();
}
// End of /Users/ec2-user/gitlab-runner/builds/E-xKdhDoq/0/foxit/sdk/mobile/harmonyrdk/script/../foxit_rdk/src/main/cpp/types/libfoxit_rdk_native/pdf/ltvverifier.d.ts
// Start of /Users/ec2-user/gitlab-runner/builds/E-xKdhDoq/0/foxit/sdk/mobile/harmonyrdk/script/../foxit_rdk/src/main/cpp/types/libfoxit_rdk_native/pdf/signature.d.ts
 
export class SignatureArray extends NativeObjectWrapper {
  constructor(r);
  constructor();
 
  GetSize();
 
  GetAt(index);
 
  Add(element);
 
  RemoveAt(index);
 
  InsertAt(index, element);
 
  RemoveAll();
}
 
export class Signature extends Field{
  static e_StateUnknown;
  static e_StateNoSignData;
  static e_StateUnsigned;
  static e_StateSigned;
  static e_StateVerifyValid;
  static e_StateVerifyInvalid;
  static e_StateVerifyErrorData;
  e_StateVerifyNoSupportWay;
  static e_StateVerifyErrorByteRange;
  static e_StateVerifyChange;
  static e_StateVerifyIncredible;
  static e_StateVerifyNoChange;
  static e_StateVerifyIssueValid;
  static e_StateVerifyIssueUnknown;
  static e_StateVerifyIssueRevoke;
  static e_StateVerifyIssueExpire;
  static e_StateVerifyIssueUncheck;
  static e_StateVerifyIssueCurrent;
  static e_StateVerifyTimestampNone;
  static e_StateVerifyTimestampDoc;
  static e_StateVerifyTimestampValid;
  static e_StateVerifyTimestampInvalid;
  static e_StateVerifyTimestampExpire;
  static e_StateVerifyTimestampIssueUnknown;
  static e_StateVerifyTimestampIssueValid;
  static e_StateVerifyTimestampTimeBefore;
  static e_StateCertCannotGetVRI;
  static e_StateVerifyChangeLegal;
  static e_StateVerifyChangeIllegal;
 
 
  static e_APFlagFoxitFlag;
  static e_APFlagLabel;
  static e_APFlagReason;
  static e_APFlagSigningTime;
  static e_APFlagDN;
  static e_APFlagLocation;
  static e_APFlagSigner;
  static e_APFlagBitmap;
  static e_APFlagText;
  static e_APFlagFoxitEditorFlag;
  static e_APFlagProducer;
 
 
  static e_KeyNameSigner;
  static e_KeyNameLocation;
  static e_KeyNameReason;
  static e_KeyNameContactInfo;
  static e_KeyNameDN;
  static e_KeyNameText;
  static e_KeyNameProducer;
 
 
  static e_DigestSHA1;
  static e_DigestSHA256;
  static e_DigestSHA384;
  static e_DigestSHA512;
 
 
  static e_SignatureTypeOrdinary;
  static e_SignatureTypeTimeStamp;
  static e_SignatureTypePagingSeal;
 
 
  static e_PAdESLevelNotPAdES;
  static e_PAdESLevelNone;
  static e_PAdESLevelBB;
  static e_PAdESLevelBT;
  static e_PAdESLevelBLT;
  static e_PAdESLevelBLTA;
 
 
  static e_DocPermUnrestricted;
  static e_DocPermNoChangesAllowed;
  static e_DocPermFillingFormAndSigning;
  static e_DocPermFillingFormSigningAndAnnotating;
 
 
  static e_FieldMDPActionNone;
  static e_FieldMDPActionAll;
  static e_FieldMDPActionInclude;
  static e_FieldMDPActionExclude;
 
 
  static e_LabelNameSigner;
  static e_LabelNameLocation;
  static e_LabelNameReason;
  static e_LabelNameSignTime;
  static e_LabelNameDN;
  static e_LabelNameProducer;
 
 
  constructor(r);
  constructor(field);
 
  constructor(document, sig_field_dict);
 
  IsEmpty();
 
  IsSigned();
 
  SetDocPermission(permission);
 
  GetDocPermission();
 
  SetFieldMDPActionFields(action, field_array);
 
  GetFieldMDPAction();
 
  GetFieldMDPActionFields();
 
  EnableIncrementalSaveForFirstSigning(enable_incremental_save);
 
  StartSign(cert_path, cert_password,
    digest_algorithm, save_path,
    client_data, pause);
  StartSignAsync(cert_path, cert_password,
    digest_algorithm, save_path,
    client_data, pause);<Progressive>;
 
  StartSign(cert_file_stream, cert_password,
    digest_algorithm, save_path,
    client_data, pause);
 
  StartSign(cert_path, cert_password,
    digest_algorithm, stream_callback,
    client_data, pause);
 
  StartVerify(client_data, pause);
 
  GetCertificateInfo(key);
 
  GetByteRangeArray(out_byte_range_array [number, number, number, number]);
 
  GetState();
 
  ClearSignedData();
 
  GetDocument();
 
  GetSignedVersionDocument(file_path);
 
  GetAppearanceFlags();
 
  SetAppearanceFlags(appearance_flags);
 
  SetAppearanceContent(appearance_content);
 
  GetSignTime();
 
  SetSignTime(sign_time);
 
  GetFilter();
 
  SetFilter(filter);
 
  GetSubFilter();
 
  SetSubFilter(sub_filter);
 
  GetKeyValue(key);
 
  SetKeyValue(key, value);
 
  SetKeyLabel(label_name, label_value);
 
  GetKeyLabel(label_name);
 
  GetBitmap();
 
  SetBitmap(bitmap);
 
  SetImage(image, frame_index);
 
  SetImage(file_path, frame_index);
 
  GetSignatureDict();
 
  SetDefaultContentsLength(default_length);
 
  GetCertCount();
 
  GetCert(index);
 
  SetCertChain(cert_chain);
 
  GetSignatureType();
 
  IsTimeStamp();
 
  GetPAdESLevel();
 
  SetCustomObject(key, pdf_object);
 
  GetPagingSealGroupElements();
 
  GenerateAppearance();
 
  GetPagingSealSignature();
 
  EnableEmbedFont(enable_embed_font);
}
 
export namespace SignatureCallback {
  export const e_CertValid;
  export const e_CertExpired;
  export const e_CertUnsupportType;
  export const e_CertDataError;
  export const e_CertInvalidPassword;
  export const e_CertInvalidPath;
  export const e_CertNotSet;
  export const e_CertCannotGetPrivateKey;
}
 
export class ISignatureCallback {
  Release();
 
  StartCalcDigest(file, byte_range_array,
    size_of_array, signature, client_data);
 
  ContinueCalcDigest(client_data, pause);
 
  GetDigest(client_data);
 
  Sign(digest, digest_length, cert_path,
    cert_password, digest_algorithm,
    client_data);
 
  Sign(digest, digest_length, cert_file_stream,
    cert_password, digest_algorithm, client_data);
 
  VerifySigState(digest, digest_length, signed_data, signed_data_len,
    client_data);
 
  IsNeedPadData();
 
  CheckCertificateValidity(cert_path, cert_password, client_data);
}
 
export class TimeStampServerMgr extends NativeObjectWrapper {
  static Initialize();
 
  static Release();
 
  static GetServerCount();
 
  static GetServer(index);
 
  static GetServerIndex(server);
 
  static GetDefaultServer();
 
  static SetDefaultServer(index);
 
  static SetDefaultServer(server);
 
  static AddServer(server_name, server_url, user_name, password);
 
  static RemoveServer(index);
 
  static RemoveServer(server);
}
 
export class TimeStampServer extends NativeObjectWrapper {
  static e_SendResultSuccess;
  static e_SendResultFailToCreateSocket;
  static e_SendResultFailToConnect;
  static e_SendResultFailToSendData;
  static e_SendResultFailToReceiveData;
  static e_SendResultFailToRequest;
  static e_SendResultFailToGetData;
  static e_SendResultOutOfMemory;
 
  IsEmpty();
 
  SendTimeStampRequest(request);
 
  GetTimeStampMessage();
}
 
export class ITimeStampCallback {
  Release();
 
  SendTimeStampRequest(request);
 
  GetTimeStampMessage();
}
 
export class PagingSealConfig extends NativeObjectWrapper {
  static e_PagingSealPositionLeft;
  static e_PagingSealPositionRight;
  static e_PagingSealPositionTop;
  static e_PagingSealPositionBottom;
 
 
  static e_PagingSealStyleMultipleSignatures;
  static e_PagingSealStyleOneSignature;
 
  constructor(r);
  constructor(paging_seal_position, offset, first_page_percent, is_on_perforation,
    paging_seal_style, is_display_multiple_seal, page_count_for_each_seal);
 
 
  Set(paging_seal_position, offset, first_page_percent, is_on_perforation,
    paging_seal_style, is_display_multiple_seal, page_count_for_each_seal);
 
 
  paging_seal_position;
  offset;
  first_page_percent;
  is_on_perforation
  paging_seal_style;
  is_display_multiple_seal
  page_count_for_each_seal;
}
 
export class PagingSealSignature extends Signature {
  static e_PagingSealAPStateUnknown;
  static e_PagingSealAPStateUnsigned;
  static e_PagingSealAPStateSigned;
  static e_PagingSealAPStateValid;
  static e_PagingSealAPStateInvalid;
 
 
  SetPagingSealConfig(paging_seal_config);
 
  SetAPStateBitmap(ap_state, bitmap);
 
  GenerateAppearance();
}
// End of /Users/ec2-user/gitlab-runner/builds/E-xKdhDoq/0/foxit/sdk/mobile/harmonyrdk/script/../foxit_rdk/src/main/cpp/types/libfoxit_rdk_native/pdf/signature.d.ts
// Start of /Users/ec2-user/gitlab-runner/builds/E-xKdhDoq/0/foxit/sdk/mobile/harmonyrdk/script/../foxit_rdk/src/main/cpp/types/libfoxit_rdk_native/pdf/annots/annots.d.ts
 
export class DefaultAppearance extends NativeObjectWrapper {
  static e_FlagFont;
  static e_FlagTextColor;
  static e_FlagFontSize;
 
  constructor(r);
  constructor(flags, font, text_size, text_color);
 
  constructor();
 
  Set(flags, font, text_size, text_color);
 
  flags;
  font;
  text_size;
  text_color;
}
 
export class RichTextStyle extends NativeObjectWrapper {
  static e_CornerMarkNone;
  static e_CornerMarkSuperscript;
  static e_CornerMarkSubscript;
 
  constructor(r);
  constructor(font, text_size, text_alignment, text_color,
    is_bold, is_italic, is_underline, is_strikethrough, mark_style);
 
 
  constructor();
 
  Set(font, text_size, text_alignment, text_color,
    is_bold, is_italic, is_underline, is_strikethrough, mark_style);
 
  font;
  text_size;
  text_alignment;
  text_color;
  is_bold;
  is_italic;
  is_underline;
  is_strikethrough;
  mark_style;
}
 
 
export class BorderInfo extends NativeObjectWrapper {
  static e_Solid;
  static e_Dashed;
  static e_UnderLine;
  static e_Beveled;
  static e_Inset;
  static e_Cloudy;
 
  constructor(r);
  constructor(width, style, intensity, dash_phase, dashes);
 
  constructor();
 
  Set(width, style, intensity, dash_phase, dashes);
 
 
  width;
 
  style;
 
  cloud_intensity;
 
  dash_phase;
 
  dashes;
}
 
export class QuadPoints extends NativeObjectWrapper {
  constructor(r);
  constructor(first, second, third, fourth)
 
  
  constructor();
 
  Set(first, second, third, fourth);
 
  first;
  second;
  third;
  fourth;
}
 
export class QuadPointsArray extends NativeObjectWrapper {
  constructor(r);
  constructor();
 
  GetSize();
 
  GetAt(index);
 
  Add(element);
 
  RemoveAt(index);
 
  InsertAt(index, element);
 
  RemoveAll();
}
 
export class IconFit extends NativeObjectWrapper {
  static e_ScaleWayNone;
  static e_ScaleWayAlways;
  static e_ScaleWayBigger;
  static e_ScaleWaySmaller;
  static e_ScaleWayNever;
 
  constructor(r);
  constructor();
 
  constructor(type, is_proportional_scaling, horizontal_fraction,
    vertical_fraction, fit_bounds);
 
  Set(type, is_proportional_scaling, horizontal_fraction,
    vertical_fraction, fit_bounds);
 
 
  scale_way_type;
  is_proportional_scaling;
  horizontal_fraction;
  vertical_fraction;
  fit_bounds;
}
 
export class Annot extends NativeObjectWrapper {
  static e_UnknownType;
  static e_Note;
  static e_Link;
  static e_FreeText;
  static e_Line;
  static e_Square;
  static e_Circle;
  static e_Polygon;
  static e_PolyLine;
  static e_Highlight;
  static e_Underline;
  static e_Squiggly;
  static e_StrikeOut;
  static e_Stamp;
  static e_Caret;
  static e_Ink;
  static e_PSInk;
  static e_FileAttachment;
  static e_Sound;
  static e_Movie;
  static e_Widget;
  static e_Screen;
  static e_PrinterMark;
  static e_TrapNet;
  static e_Watermark;
  static e_3D;
  static e_Popup;
  static e_Redact;
  static e_RichMedia;
  static e_PagingSeal;
 
 
  static e_FlagInvisible;
  static e_FlagHidden;
  static e_FlagPrint;
  static e_FlagNoZoom;
  static e_FlagNoRotate;
  static e_FlagNoView;
  static e_FlagReadOnly;
  static e_FlagLocked;
  static e_FlagToggleNoView;
  static e_FlagLockedContents;
 
 
  static e_HighlightingNone;
  static e_HighlightingInvert;
  static e_HighlightingOutline;
  static e_HighlightingPush;
  static e_HighlightingToggle;
 
  static e_PropertyModifiedDate;
  static e_PropertyCreationDate;
  static e_PropertyBorderColor;
  static e_PropertyFillColor;
 
  static e_MKEntryRotation;
  static e_MKEntryBorderColor;
  static e_MKEntryBackgroundColor;
  static e_MKEntryNormalCaption;
  static e_MKEntryRolloverCaption;
  static e_MKEntryDownCaption;
  static e_MKEntryNormalIcon;
  static e_MKEntryRolloverIcon;
  static e_MKEntryDownIcon;
  static e_MKEntryIconFit;
  static e_MKEntryIconCaptionRelation;
 
 
  static e_MKRelationNoIcon;
  static e_MKRelationNoCaption;
  static e_MKRelationCaptionBelowIcon;
  static e_MKRelationCaptionAboveIcon;
  static e_MKRelationCaptionRight;
  static e_MKRelationCaptionLeft;
  static e_MKRelationCaptionOvrlayOnIcon;
 
 
  static e_AppearanceTypeNormal;
  static e_AppearanceTypeRollover;
  static e_AppearanceTypeDown;
 
  constructor(r);
 
  constructor(annot);
 
  constructor(page, annot_dict);
 
  constructor();
 
  IsEmpty();
 
  GetPage();
 
  IsMarkup();
 
  GetType();
 
  GetIndex();
 
  GetContent();
 
  SetContent(content);
 
  GetModifiedDateTime();
 
  SetModifiedDateTime(date_time);
 
  GetFlags();
 
  SetFlags(flags);;
 
  GetUniqueID();
 
  SetUniqueID(unique_id);
 
  GetRect();
 
  GetDisplayMatrix(page_display_matrix);
 
  Move(rect);
 
  Move(rect, is_reset_appearance);
 
  GetBorderInfo();
 
  SetBorderInfo(border);
 
  GetBorderColor();
 
  SetBorderColor(color);
 
  ResetAppearanceStream();
  ResetAppearanceStreamAsync();<boolean>;
 
  ResetAppearanceStream(is_generate_new_appearance_obj);
 
  GetDeviceRect(matrix);
 
  GetDict();
 
  HasProperty(property);
 
  RemoveProperty(property);
 
  GetOptionalContent();
 
  GetAppearanceStream(type, appearance_state);
}
 
export class AnnotArray extends NativeObjectWrapper {
  constructor(r);
  constructor();
 
  GetSize();
 
  GetAt(index);
 
  Add(element);
 
  RemoveAt(index);
 
  InsertAt(index, element);
 
  RemoveAll();
}
 
 
export class ShadingColor extends NativeObjectWrapper {
  constructor(r);
  constructor(firstcolor, secondcolor);
 
  constructor();
 
  Set(firstcolor, secondcolor);
 
  first_color;
  second_color;
}
 
export class IIconProviderCallback {
  Release();
 
  GetProviderID();
 
  GetProviderVersion();
 
  HasIcon(annot_type, icon_name);
 
  CanChangeColor(annot_type, icon_name);
 
 
  GetIcon(annot_type, icon_name, color, annot_dict);
 
  GetShadingColor(annot_type, icon_name,
    referenced_color, shading_index, out_shading_color);
 
  GetDisplayWidth(annot_type, icon_name);
 
  GetDisplayHeight(annot_type, icon_name);
}
 
export class MarkupArray extends NativeObjectWrapper {
  constructor(r);
  constructor();
 
  GetSize();
 
  GetAt(index);
 
  Add(element);
 
  RemoveAt(index);
 
  InsertAt(index, element);
 
  RemoveAll();
}
 
export class NoteArray extends NativeObjectWrapper {
  constructor(r);
  constructor();
 
  GetSize();
 
  GetAt(index);
 
  Add(element);
 
  RemoveAt(index);
 
  InsertAt(index, element);
 
  RemoveAll();
}
 
export class Markup extends Annot {
  static e_StateModelMarked;
  static e_StateModelReview;
 
 
  static e_StateNone;
  static e_StateMarked;
  static e_StateUnmarked;
  static e_StateAccepted;
  static e_StateRejected;
  static e_StateCancelled;
  static e_StateCompleted;
  static e_StateDeferred;
  static e_StateFuture;
 
 
  static e_EndingStyleNone;
  static e_EndingStyleSquare;
  static e_EndingStyleCircle;
  static e_EndingStyleDiamond;
  static e_EndingStyleOpenArrow;
  static e_EndingStyleClosedArrow;
  static e_EndingStyleButt;
  static e_EndingStyleROpenArrow;
  static e_EndingStyleRClosedArrow;
  static e_EndingStyleSlash;
 
 
  static e_MeasureTypeX;
  static e_MeasureTypeY;
  static e_MeasureTypeD;
  static e_MeasureTypeA;
  static e_MeasureTypeT;
  static e_MeasureTypeS;
 
  constructor(r);
  constructor(annot);
 
  constructor();
 
  GetPopup();
 
  SetPopup(popup);
 
  RemovePopup();
 
  GetTitle();
 
  SetTitle(title);
 
  GetSubject();
 
  SetSubject(subject);
 
  GetOpacity();
 
  SetOpacity(opacity);
 
  GetIntent();
 
  SetIntent(intent);
 
  GetCreationDateTime();
 
  SetCreationDateTime(date_time);
 
  GetReplyCount();
 
  GetReply(index);
 
  AddReply();
 
  RemoveReply(index);
 
  RemoveAllReplies();
 
  IsGrouped();
 
  GetGroupHeader();
 
  GetGroupElements();
 
  Ungroup();
 
  GetStateAnnots(model);
 
  AddStateAnnot(title, model, state);
 
  RemoveAllStateAnnots();
 
  GetRichTextCount();
 
  GetRichTextContent(index);
 
  SetRichTextContent(index, content);
 
  GetRichTextStyle(index);
 
  SetRichTextStyle(index, style);
 
  AddRichText(content, style);
 
  InsertRichText(index, content, style);
 
  RemoveRichText(index);
 
  SetBorderOpacity(opacity);
 
  GetBorderOpacity();
 
  SetFillOpacity(opacity);
 
  GetFillOpacity();
}
 
export class Note extends Markup {
  constructor(r);
  constructor();
 
  constructor(annot);
 
  GetOpenStatus();
 
  SetOpenStatus(status);
 
  GetIconName();
 
  SetIconName(icon_name);
 
  GetReplyTo();
 
  IsStateAnnot();
 
  GetStateModel();
 
  GetState();
 
  SetState(state);
}
 
export class TextMarkup extends Markup {
  constructor(r);
  constructor();
 
  constructor(annot);
 
 
  GetQuadPoints();
 
  SetQuadPoints(quad_points_array);
}
 
export class Highlight extends TextMarkup {
  constructor(r);
  constructor();
 
  constructor(annot);
}
 
export class Underline extends TextMarkup {
  constructor(r);
  constructor();
 
  constructor(annot);
}
 
export class StrikeOut extends TextMarkup {
  constructor(r);
  constructor();
 
  constructor(annot);
}
 
export class Squiggly extends TextMarkup {
  constructor(r);
  constructor();
 
  constructor(annot);
}
 
export class Link extends Annot {
  constructor(r);
  constructor();
 
  constructor(annot);
 
  GetQuadPoints();
 
  SetQuadPoints(quad_points_array);
 
  GetHighlightingMode();
 
  SetHighlightingMode(mode);
 
  GetAction();
 
  SetAction(action);
 
  RemoveAction();
 
  ExecuteJavaScriptAction();
}
 
export class Square extends Markup {
  constructor(r);
  constructor();
 
  constructor(annot);
 
  GetFillColor();
 
  SetFillColor(fill_color);
 
  GetInnerRect();
 
  SetInnerRect(inner_rect);
 
  SetMeasureRatio(ratio);
 
  GetMeasureRatio();
 
  GetMeasureRatioW();
 
  SetMeasureUnit(Mmeasure_type, unit);
 
  GetMeasureUnit(measure_type);
 
  GetMeasureUnitW(measure_type);
 
  SetMeasureConversionFactor(measure_type, factor);
 
  GetMeasureConversionFactor(measure_type);
}
 
export class Circle extends Markup {
  constructor(r);
  constructor();
 
  constructor(annot);
 
  GetFillColor();
 
  SetFillColor(fill_color);
 
  GetInnerRect();
 
  SetInnerRect(inner_rect);
 
  SetMeasureRatio(ratio);
 
  GetMeasureRatio();
 
  GetMeasureRatioW();
 
  SetMeasureUnit(measure_type, unit);
 
  GetMeasureUnit(measure_type);
 
  GetMeasureUnitW(measure_type);
 
  SetMeasureConversionFactor(measure_type, factor);
 
  GetMeasureConversionFactor(measure_type);
}
 
export class FreeText extends Markup {
  constructor(r);
  constructor();
 
  constructor(annot);
 
  GetFillColor();
 
  SetFillColor(fill_color);
 
  GetAlignment();
 
  SetAlignment(alignment);
 
  GetInnerRect();
 
  SetInnerRect(inner_rect);
 
  GetDefaultAppearance();
 
  SetDefaultAppearance(default_ap);
 
  GetCalloutLineEndingStyle();
 
  SetCalloutLineEndingStyle(ending_style);
 
  GetCalloutLinePoints();
 
  SetCalloutLinePoints(point_array);
 
  SetTextMatrix(text_matrix);
 
  GetTextMatrix();
 
  GetRotation();
 
  SetRotation(rotation);
 
  Rotate(rotation);
 
  AllowTextOverflow(is_text_overflow);
}
 
export class Line extends Markup {
  static e_CapPosInline;
  static e_CapPosTop;
 
  constructor(r);
  constructor();
 
  constructor(annot);
 
  GetLineStartStyle();
 
  SetLineStartStyle(ending_style);
 
  GetLineEndStyle();
 
  SetLineEndStyle(ending_style);
 
  GetStyleFillColor();
 
  SetStyleFillColor(color);
 
  GetStartPoint();
 
  SetStartPoint(point);
 
  GetEndPoint();
 
  SetEndPoint(point);
 
  HasCaption();
 
  EnableCaption(cap);
 
  GetCaptionPositionType();
 
  SetCaptionPositionType(cap_position);
 
  GetCaptionOffset();
 
  SetCaptionOffset(offset);
 
  GetLeaderLineLength();
 
  SetLeaderLineLength(length);
 
  GetLeaderLineExtensionLength();
 
  SetLeaderLineExtensionLength(extension_length);
 
  GetLeaderLineOffset();
 
  SetLeaderLineOffset(offset);
 
  SetMeasureRatio(ratio);
 
  GetMeasureRatio();
 
  GetMeasureRatioW();
 
  SetMeasureUnit(measure_type, unit);
 
  GetMeasureUnit(measure_type);
 
  GetMeasureUnitW(measure_type);
 
  SetMeasureConversionFactor(measure_type, factor);
 
  GetMeasureConversionFactor(measure_type);
}
 
export class Ink extends Markup {
  constructor(r);
  constructor();
 
  constructor(annot);
 
  GetInkList();
 
  SetInkList(ink_list);
 
  EnableUseBezier(use_bezier);
}
 
export class Stamp extends Markup {
  constructor(r);
  constructor();
 
  constructor(annot);
 
  GetIconName();
 
  SetIconName(icon_name);
 
  SetBitmap(bitmap);
 
  SetImage(image, frame_index, compress);
 
  SetRotation(angle);
 
  GetRotation();
 
  Rotate(angle);
}
 
export class Screen extends Annot {
  constructor(r);
  constructor();
 
  constructor(annot);
 
  SetImage(image, frame_index, compress);
 
  GetBitmap();
 
  GetMKDict();
 
  SetMKDict(dict);
 
  SetRotation(rotate);
 
  GetRotation();
 
  GetOpacity();
 
  SetOpacity(opacity);
 
  GetTitle();
 
  SetTitle(title);
 
  GetAction();
 
  SetAction(action);
 
  RemoveAction();
}
 
export class Polygon extends Markup {
  constructor(r);
  constructor();
 
  constructor(annot);
 
  GetFillColor();
 
  SetFillColor(fill_color);
 
  GetVertexes();
 
  SetVertexes(vertexes);
 
  SetMeasureRatio(ratio);
 
  GetMeasureRatio();
 
  GetMeasureRatioW();
 
  SetMeasureUnit(measure_type, unit);
 
  GetMeasureUnit(measure_type);
 
  GetMeasureUnitW(measure_type);
 
  SetMeasureConversionFactor(measure_type, factor);
 
  GetMeasureConversionFactor(measure_type);
}
 
export class PolyLine extends Markup {
  constructor(r);
  constructor();
 
  constructor(annot);
 
  GetStyleFillColor();
 
  SetStyleFillColor(fill_color);
 
  GetVertexes();
 
  SetVertexes(vertexes);
 
  GetLineStartStyle();
 
  SetLineStartStyle(starting_style);
 
  GetLineEndStyle();
 
  SetLineEndStyle(ending_style);
 
  SetMeasureRatio(ratio);
 
  GetMeasureRatio();
 
  GetMeasureRatioW();
 
  SetMeasureUnit(measure_type, unit);
 
  GetMeasureUnit(measure_type);
 
  GetMeasureUnitW(measure_type);
 
  SetMeasureConversionFactor(measure_type, factor);
 
  GetMeasureConversionFactor(measure_type);
}
 
export class Caret extends Markup {
  constructor(r);
  constructor();
 
  constructor(annot);
 
  GetInnerRect();
 
  SetInnerRect(inner_rect);
}
 
export class FileAttachment extends Markup {
  constructor(r);
  constructor();
 
  constructor(annot);
 
  SetFileSpec(file_spec);
 
  GetFileSpec();
 
  GetIconName();
 
  SetIconName(icon_name);
}
 
export class Popup extends Annot {
  constructor(r);
  constructor();
 
  constructor(annot);
 
  GetOpenStatus();
 
  SetOpenStatus(status);
 
  GetParent();
}
 
 
export class PSInk extends Annot {
  constructor(r);
  constructor();
 
  constructor(annot);
}
 
 
export class Widget extends Annot {
  static e_LineSpacingSingle;
  static e_LineSpacingOneAndHalf;
  static e_LineSpacingDouble;
  static e_LineSpacingExactValue;
  static e_LineSpacingAuto;
 
  constructor(r);
  constructor();
 
  constructor(annot);
 
  GetField();
 
  GetControl();
 
  GetHighlightingMode();
 
  SetHighlightingMode(mode);
 
  GetAction();
 
  SetAction(action);
 
  RemoveAction();
 
  HasMKEntry(mk_entry);
 
  RemoveMKEntry(mk_entry);
 
  GetMKRotation();
 
  SetMKRotation(rotation);
 
  GetMKBorderColor();
 
  SetMKBorderColor(color);
 
  GetMKBackgroundColor();
 
  SetMKBackgroundColor(color);
 
  GetMKNormalCaption();
 
  SetMKNormalCaption(caption);
 
  GetMKRolloverCaption();
 
  SetMKRolloverCaption(caption);
 
  GetMKDownCaption();
 
  SetMKDownCaption(caption);
 
  GetMKNormalIconBitmap();
 
  SetMKNormalIconBitmap(bitmap);
 
  SetMKNormalIconImage(image, frame_index);
 
  GetMKRolloverIconBitmap();
 
  SetMKRolloverIconBitmap(bitmap);
 
  SetMKRolloverIconImage(image, frame_index);
 
  GetMKDownIconBitmap();
 
  SetMKDownIconBitmap(bitmap);
 
  SetMKDownIconImage(image, frame_index);
 
  GetMKIconFit();
 
  SetMKIconFit(icon_fit);
 
  GetMKIconCaptionRelation();
 
  SetMKIconCaptionRelation(relation);
 
  SetAppearanceState(appearance_state);
 
  GetAppearanceState();
 
  GetAppearanceOnStateName();
 
  GetLineSpacing(line_spacing_value);
 
  SetLineSpacing(line_spacing_style, line_spacing_value);
}
 
export class Redact extends Markup {
  constructor(r);
  constructor();
 
  constructor(annot);
 
  GetQuadPoints();
 
  SetQuadPoints(quad_points_array);
 
  GetFillColor();
 
  SetFillColor(fill_color);
 
  GetApplyFillColor();
 
  SetApplyFillColor(fill_color);
 
  GetOverlayText();
 
  SetOverlayText(overlay_text);
 
  IsOverlayTextRepeated();
 
  EnableRepeatOverlayText(is_to_repeat_overlay_text);
 
  GetOverlayTextAlignment();
 
  SetOverlayTextAlignment(alignment);
 
  EnableAutoFontSize();
 
  GetDefaultAppearance();
 
  SetDefaultAppearance(default_ap);
 
  Apply();
}
 
export class Sound extends Markup {
  static e_SampleEncodingFormatRaw;
  static e_SampleEncodingFormatSigned;
  static e_SampleEncodingFormatMuLaw;
  static e_SampleEncodingFormatALaw;
 
  constructor(r);
  constructor();
 
  constructor(annot);
 
  GetSoundStream();
 
  GetSamplingRate();
 
  GetChannelCount();
 
  GetBits();
 
  GetSampleEncodingFormat();
 
  GetCompressionFormat();
 
  GetFileSpec();
}
 
export class PagingSeal extends Annot {
  constructor(r);
  constructor(annot);
 
  GetPagingSealSignature();
}
// End of /Users/ec2-user/gitlab-runner/builds/E-xKdhDoq/0/foxit/sdk/mobile/harmonyrdk/script/../foxit_rdk/src/main/cpp/types/libfoxit_rdk_native/pdf/annots/annots.d.ts
// Start of /Users/ec2-user/gitlab-runner/builds/E-xKdhDoq/0/foxit/sdk/mobile/harmonyrdk/script/../foxit_rdk/src/main/cpp/types/libfoxit_rdk_native/pdf/interform/form.d.ts
 
export namespace FillerAssistCallback {
  export const e_PopupMenuItemNone;
  export const e_PopupMenuItemCut;
  export const e_PopupMenuItemCopy;
  export const e_PopupMenuItemPaste;
  export const e_PopupMenuItemDelete;
  export const e_PopupMenuItemSelectAll;
}
 
export class IFillerAssistCallback {
  Release();
 
  GetVersion();
 
  Refresh(page, rect);
 
  SetTimerCallback(elapse, timer) [boolean, number];
 
  KillTimer(timer_id);
 
  FocusGotOnControl(control, value);
 
  FocusLostFromControl(control, value);
 
  CreatePopupMenu();
 
  AppendPopupMenuItem(h_popup_menu, popup_menu_item, default_string);
 
  EnablePopupMenuItem(h_popup_menu, popup_menu_item, is_enabled);
 
  ShowPopupMenu(h_popup_menu, point);
 
  DestroyPopupMenu(h_popup_menu);
 
  SetClipboardText(text);
 
  GetClipboardText();
 
  ReportInvalidValue(form_field_name, invalid_value);
}
 
export class Filler extends NativeObjectWrapper {
  static e_VkeyUnknown;
  static e_VkeyBack;
  static e_VkeyTab;
  static e_VkeyReturn;
  static e_VkeyShift;
  static e_VkeyControl;
  static e_VkeyMenu;
  static e_VkeyPause;
  static e_VkeyEscape;
  static e_VkeySpace;
  static e_VkeyPrior;
  static e_VkeyNext;
  static e_VkeyEnd;
  static e_VkeyHome;
  static e_VkeyLeft;
  static e_VkeyUp;
  static e_VkeyRight;
  static e_VkeyDown;
  static e_VkeyPrint;
  static e_VkeySnapshot;
  static e_VkeyInsert;
  static e_VkeyDelete;
  static e_VkeyHelp;
  static e_Vkey0;
  static e_Vkey1;
  static e_Vkey2;
  static e_Vkey3;
  static e_Vkey4;
  static e_Vkey5;
  static e_Vkey6;
  static e_Vkey7;
  static e_Vkey8;
  static e_Vkey9;
  static e_VkeyA;
  static e_VkeyB;
  static e_VkeyC;
  static e_VkeyD;
  static e_VkeyE;
  static e_VkeyF;
  static e_VkeyG;
  static e_VkeyH;
  static e_VkeyI;
  static e_VkeyJ;
  static e_VkeyK;
  static e_VkeyL;
  static e_VkeyM;
  static e_VkeyN;
  static e_VkeyO;
  static e_VkeyP;
  static e_VkeyQ;
  static e_VkeyR;
  static e_VkeyS;
  static e_VkeyT;
  static e_VkeyU;
  static e_VkeyV;
  static e_VkeyW;
  static e_VkeyX;
  static e_VkeyY;
  static e_VkeyZ;
  e_VkeyNumpad0;
  static e_VkeyNumpad1;
  static e_VkeyNumpad2;
  static e_VkeyNumpad3;
  static e_VkeyNumpad4;
  static e_VkeyNumpad5;
  static e_VkeyNumpad6;
  static e_VkeyNumpad7;
  static e_VkeyNumpad8;
  static e_VkeyNumpad9;
  static e_VkeyMultiply;
  static e_VkeyAdd;
  static e_VkeySeparator;
  static e_VkeySubtractv;
  static e_VkeyDecimal;
  static e_VkeyDivide;
  static e_VkeyF1;
  static e_VkeyF2;
  static e_VkeyF3;
  static e_VkeyF4;
  static e_VkeyF5;
  static e_VkeyF6;
  static e_VkeyF7;
  static e_VkeyF8;
  static e_VkeyF9;
  static e_VkeyF10;
  static e_VkeyF11;
  static e_VkeyF12;
 
 
  static e_EventFlagShiftKey;
  static e_EventFlagControlKey;
  static e_EventFlagAltKey;
  static e_EventFlagMetaKey;
  static e_EventFlagKeyPad;
  static e_EventFlagAutoRepeat;
  static e_EventFlagLeftButtonDown;
  static e_EventFlagMiddleButtonDown;
  static e_EventFlagRightButtonDown;
  static e_EventFlagCommand;
 
  constructor(r);
  constructor(form, assist);
 
  IsEmpty();
 
  Render(page, matrix, renderer);
  RenderAsync(page, matrix, renderer);<void>;
 
  OnLButtonDown(page, point, flags);
  OnLButtonDownAsync(page, point, flags);<boolean>;
 
  OnLButtonUp(page, point, flags);
  OnLButtonUpAsync(page, point, flags);<boolean>;
 
  OnLButtonDoubleClick(page, point, flags);
 
  OnMouseMove(page, point, flags);
  OnMouseMoveAsync(page, point, flags);<boolean>;
 
  OnMouseEnter(page, point, flags);
 
  OnMouseHover(page, point, flags);
 
  OnMouseLeave(page, point, flags);
 
  OnMouseWheel(page, point, delta, flags);
 
  OnRButtonDown(page, point, flags);
  OnRButtonDownAsync(page, point, flags);<boolean>;
 
  OnRButtonUp(page, point, flags);
  OnRButtonUpAsync(page, point, flags);<boolean>;
 
  OnRButtonDoubleClick(page, point, flags);
 
  OnWheelButtonDown(page, point, flags);
 
  OnWheelButtonUp(page, point, flags);
 
  OnWheelButtonDoubleClick(page, point, flags);
 
  OnKeyDown(key_code, flags);
 
  OnKeyUp(key_code, flags);
 
  OnChar(key_code, flags);
 
  SetFocus(control);
 
  KillFocus();
 
  HighlightFormFields(is_highlight);
 
  HighlightFormFields(is_highlight, is_sign_highlight);
 
  SetHighlightColor(color);
 
  ShowOverflowIndicator(is_show_overflow_indicator);
 
  OnCut();
 
  OnCopy();
 
  OnPaste();
 
  OnSelectAll();
 
  OnDelete();
 
  GetEditingTextCaretPosition(matrix);
}
 
 
export class FieldArray extends NativeObjectWrapper {
  constructor(r);
  constructor();
 
  GetSize();
 
  GetAt(index);
 
  Add(element);
 
  RemoveAt(index);
 
  InsertAt(index, element);
 
  RemoveAll();
}
 
export class ChoiceOption extends NativeObjectWrapper {
  constructor(r);
  constructor();
 
  constructor(option_value, option_label, selected, default_selected)
 
  
  Set(option_value, option_label, selected, default_selected);
 
  option_value;
 
  option_label;
 
  selected;
 
  default_selected;
}
 
export class ChoiceOptionArray extends NativeObjectWrapper {
  constructor(r);
  constructor();
 
  GetSize();
 
  GetAt(index);
 
  Add(element);
 
  RemoveAt(index);
 
  InsertAt(index, element);
 
  RemoveAll();
}
 
export class Field extends NativeObjectWrapper {
  static e_TypeUnknown;
  static e_TypePushButton;
  static e_TypeCheckBox;
  static e_TypeRadioButton;
  static e_TypeComboBox;
  static e_TypeListBox;
  static e_TypeTextField;
  static e_TypeSignature;
 
 
  static e_FlagReadOnly;
  static e_FlagRequired;
  static e_FlagNoExport;
  static e_FlagButtonNoToggleToOff;
  static e_FlagButtonRadiosInUnison;
  static e_FlagTextMultiline;
  static e_FlagTextPassword;
  static e_FlagTextFileSelect;
  static e_FlagTextNoSpellCheck;
  static e_FlagTextDoNotScroll;
  static e_FlagTextComb;
  static e_FlagComboEdit;
  static e_FlagChoiceMultiSelect;
  static e_FlagTextRichText;
  static e_FlagChoiceSort;
  static e_FlagChoiceCommitOnSelChange;
 
  constructor(r);
  constructor(document, field_dict);
 
  constructor(field);
 
  IsEmpty();
 
  GetType();
 
  GetFlags();
 
  SetFlags(flags);
 
  GetName();
 
  GetDefaultValue();
 
  SetDefaultValue(value);
 
  GetValue();
 
  SetValue(value);
 
  GetAlignment();
 
  SetAlignment(alignment);
 
  GetAlternateName();
 
  SetAlternateName(alternate_name);
 
  GetDefaultAppearance();
 
  SetDefaultAppearance(default_ap);
 
  GetMappingName();
 
  SetMappingName(name);
 
  GetMaxLength();
 
  SetMaxLength(max_length);
 
  GetOptions();
 
  SetOptions(option_array);
 
  GetTopVisibleIndex();
 
  SetTopVisibleIndex(index);
 
  GetControlCount();
 
  GetControl(index);
 
  GetControlCount(page);
 
  GetControl(page, index);
 
  Reset();
 
  GetDict();
 
  GetValueObj();
 
  GetDefaultValueObj();
 
  GetInheritedAttribute(attribute_name);
}
 
export class Form extends NativeObjectWrapper {
  constructor(r);
  constructor(document);
 
  IsEmpty();
 
  GetAlignment();
 
  SetAlignment(alignment);
 
  NeedConstructAppearances();
 
  SetConstructAppearances(need_construct);
 
  GetControlAtDevicePoint(page, point, tolerance, type,
    matrix);
 
  GetControlAtPoint(page, point, tolerance, type);
 
  GetDefaultAppearance();
 
  SetDefaultAppearance(default_ap);
 
  GetDocument();
 
  GetFieldsInCalculationOrder();
 
  SetFieldsInCalculationOrder(field_array);
 
  ValidateFieldName(type, field_name);
 
  RenameField(field, new_field_name);
 
  AddControl(page, field_name, field_type, rect);
 
  MoveControl(control, field_name);
 
  RemoveField(field);
 
  RemoveControl(control);
 
  GetFieldCount(filter);
 
  GetField(index, filter);
 
  GetControlCount(page);
 
  GetControl(page, index);
 
  GetFormFiller();
 
 
  Reset();
 
  ExportToXML(file_path);
 
  ExportToXML(file_path, field_array, is_include);
 
  ExportToXML(xml_file, field_array, is_include);
 
  ImportFromXML(file_path);
 
  ExportToCSV(csv_file_path, pdf_file_name, is_append);
 
  ExportToCSV(csv_file, pdf_file_name, is_append);
 
  ExportToHTML(html_file_path, field_array, is_include);
 
  ExportToHTML(html_file, field_array, is_include);
 
  ExportToTXT(txt_file_path, field_array, is_include);
 
  ExportToTXT(txt_file, field_array, is_include);
 
  GetDict();
 
  FixPageFields(page_index);
}
 
export class Control extends NativeObjectWrapper {
  IsEmpty();
 
  GetField();
 
  GetWidgetDict();
 
  GetWidget();
 
  GetIndex();
 
  GetExportValue();
 
  SetExportValue(value);
 
  IsChecked();
 
  SetChecked(checked_status);
 
  IsDefaultChecked();
 
  SetDefaultChecked(checked_status);
 
  GetDefaultAppearance();
 
  SetDefaultAppearance(default_ap);
 
  GetAlignment();
 
  SetAlignment(alignment);
}
 
 
export class ITimerCallback {
  OnTimer(timer);
}
// End of /Users/ec2-user/gitlab-runner/builds/E-xKdhDoq/0/foxit/sdk/mobile/harmonyrdk/script/../foxit_rdk/src/main/cpp/types/libfoxit_rdk_native/pdf/interform/form.d.ts
// Start of /Users/ec2-user/gitlab-runner/builds/E-xKdhDoq/0/foxit/sdk/mobile/harmonyrdk/script/../foxit_rdk/src/main/cpp/types/libfoxit_rdk_native/pdf/objects/pdfobject.d.ts
 
export class PDFNameTree extends NativeObjectWrapper {
  static e_Dests;
  static e_JavaScript;
  static e_EmbeddedFiles;
  static e_Pages;
  static e_Templates;
 
  constructor(r);
  constructor(document, type);
 
  IsEmpty();
 
  GetType();
 
  HasName(name);
 
  GetCount();
 
  GetName(index);
 
  GetObj(name);
 
  SetObj(name, pdf_object);
 
  Rename(old_name, new_name);
 
  Add(name, pdf_object);
 
  RemoveObj(name);
 
  RemoveAllObjs();
}
 
export class PDFNumberTree extends NativeObjectWrapper {
  static e_PageLabels;
 
  constructor(r);
  constructor(document, type);
 
  IsEmpty();
 
  GetType();
 
  HasNumber(number);
 
  GetObj(number);
 
  SetObj(number, pdf_object);
 
  RemoveObj(number);
 
  RemoveAllObjs();
}
 
export class PDFObject extends NativeObjectWrapper {
  static e_InvalidType;
  static e_Boolean;
  static e_Number;
  static e_String;
  static e_Name;
  static e_Array;
  static e_Dictionary;
  static e_Stream;
  static e_Null;
  static e_Reference;
 
 
  static CreateFromBoolean(boolean_value);
 
  static CreateFromFloat(float_value);
 
  static CreateFromInteger(integer_value);
 
  static CreateFromString(string_value);
 
  static CreateFromName(name);
 
  static CreateFromDateTime(date_time);
 
  static CreateReference(document, object_number);
 
  Release();
 
  CloneObject();
 
  DeepCloneObject();
 
  IsIdentical(pdf_obj);
 
  GetType();
 
  GetObjNum();
 
  GetInteger();
 
  GetFloat();
 
  GetBoolean();
 
  GetMatrix();
 
  GetRect();
 
  GetDirectObject();
 
  GetDateTime();
 
  GetName();
 
  GetString();
 
  GetWideString();
 
  GetArray();
 
  GetDict();
 
  GetStream();
}
 
export class PDFStream extends PDFObject {
  static e_Unknown;
  static e_NoneDecode;
  static e_ASCIIHexDecode;
  static e_ASCII85Decode;
  static e_LZWDecode;
  static e_FlateDecode;
  static e_RunLengthDecode;
  static e_CCITTFaxDecode;
  static e_JBIG2Decode;
  static e_DCTDecode;
  static e_JPXDecode;
  static e_Crypt;
 
 
  static Create(dictionary);
 
  GetDictionary();
 
  GetStreamFilter();
 
  GetDataSize(is_raw_data);
 
  GetData(is_raw_data, size, out_buffer);
 
  SetData(buffer, size);
 
  ImportData(file_read, stream_filter);
 
  ExportData(is_raw_data);
}
 
export class PDFArray extends PDFObject {
  static Create();
 
  static CreateFromMatrix(matrix);
 
  static CreateFromRect(rect);
 
  GetElementCount();
 
  GetElement(index);
 
  AddElement(element);
 
  AddBoolean(boolean_value);
 
  AddDateTime(date_time);
 
  AddFloat(float_value);
 
  AddInteger(integer_value);
 
  AddMatrix(matrix);
 
  AddRect(rect);
 
  AddName(name);
 
  AddString(new_string);
 
  InsertAt(index, element);
 
  SetAt(index, element);
 
  RemoveAt(index);
 
  AddReference(pdf_object, document);
}
 
export class PDFDictionary extends PDFObject {
  static Create();
 
  HasKey(key);
 
  GetElement(key);
 
  MoveNext(position);
 
  GetKey(position);
 
  GetValue(position);
 
  SetAt(key, pdf_object);
 
  SetAtReference(key, pdf_object, document);
 
  SetAtBoolean(key, value);
 
  SetAtDateTime(key, value);
 
  SetAtFloat(key, value);
 
  SetAtInteger(key, value);
 
  SetAtMatrix(key, value);
 
  SetAtRect(key, value);
 
  SetAtName(key, value);
 
  SetAtString(key, value);
 
  RemoveAt(key);
}
 
export class StructTreeEntity extends NativeObjectWrapper {
  static e_UnknownType;
  static e_StructTreeEntityTypeElement;
  static e_StructTreeEntityTypeMarkedContent;
  static e_StructTreeEntityTypeObjectContent;
 
  constructor(r);
  constructor();
 
  IsEmpty();
 
  GetType();
 
  GetPage();
}
 
export class StructElement extends StructTreeEntity {
  static e_ElementInfoTypeTitle;
  static e_ElementInfoTypeLanguage;
  static e_ElementInfoTypeAltDescription;
  static e_ElementInfoTypeExpandedForm;
  static e_ElementInfoTypeActualText;
 
  constructor(r);
  constructor();
 
  GetStructureTypeName();
 
  GetChildCount();
 
  GetChild(index);
 
  HasElementInfo(type);
 
  GetElementInfo(type);
 
  GetParentElement();
}
 
export class StructMarkedContent extends StructTreeEntity {
  constructor(r);
  constructor();
 
  GetParentElement();
 
  GetMCID();
 
  GetStmDict();
 
  GetStmOwnerDict();
}
 
export class StructObjectContent extends StructTreeEntity {
  static e_UnknownType;
  static e_StructObjectTypeInvalid;
  static e_StructObjectTypeImage;
  static e_StructObjectTypeForm;
  static e_StructObjectTypeAnnot;
 
  constructor(r);
  constructor();
 
 
  GetParentElement();
 
  GetObjectType();
 
  GetDict();
}
 
export class PDFStructTree extends NativeObjectWrapper {
  constructor(r);
  constructor(document);
 
  IsEmpty();
 
  GetChildCount();
 
  GetChild(index);
}
 
export class PDFDictionaryArray extends NativeObjectWrapper {
  constructor();
 
  GetSize();
 
  GetUpperBound();
 
  SetSize(nNewSize, nGrowBy);
 
  RemoveAll();
 
  GetAt(nIndex);
 
  SetAt(nIndex, newElement);
 
  SetAtGrow(nIndex, newElement);
 
  Add(newElement);
 
  InsertAt(nIndex, newElement, nCount);
 
  RemoveAt(nIndex, nCount);
 
  InsertAt(nStartIndex, pNewArray);
 
  Find(data, iStart);
}
// End of /Users/ec2-user/gitlab-runner/builds/E-xKdhDoq/0/foxit/sdk/mobile/harmonyrdk/script/../foxit_rdk/src/main/cpp/types/libfoxit_rdk_native/pdf/objects/pdfobject.d.ts
// Start of /Users/ec2-user/gitlab-runner/builds/E-xKdhDoq/0/foxit/sdk/mobile/harmonyrdk/script/../foxit_rdk/src/main/cpp/types/libfoxit_rdk_native/pdf/actions/actions.d.ts
 
export class Destination extends NativeObjectWrapper {
  static e_ZoomXYZ;
  static e_ZoomFitPage;
  static e_ZoomFitHorz;
  static e_ZoomFitVert;
  static e_ZoomFitRect;
  static e_ZoomFitBBox;
  static e_ZoomFitBHorz;
  static e_ZoomFitBVert;
 
 
  static CreateXYZ(document, page_index, left, top, zoom_factor);
 
  static CreateFitPage(document, page_index);
 
  static CreateFitHorz(document, page_index, top);
 
  static CreateFitVert(document, page_index, left);
 
  static CreateFitRect(document, page_index,
    left, bottom, right, top);
 
  static CreateFitBBox(document, page_index);
 
  static CreateFitBHorz(document, page_index, top);
 
  static CreateFitBVert(document, page_index, left);
 
  static CreateFromPDFArray(document, opdf_array);
 
  IsEmpty();
 
  GetPageIndex(document);
 
  GetZoomMode();
 
  GetLeft();
 
  IsLeftNull();
 
  GetTop();
 
  IsTopNull();
 
  GetRight();
 
  GetBottom();
 
  GetZoomFactor();
 
  GetDestArray();
}
 
 
export class Action extends NativeObjectWrapper {
  static e_TypeUnknown;
  static e_TypeGoto;
  static e_TypeGoToR;
  static e_TypeGoToE;
  static e_TypeLaunch;
  static e_TypeThread;
  static e_TypeURI;
  static e_TypeSound;
  static e_TypeMovie;
  static e_TypeHide;
  static e_TypeNamed;
  static e_TypeSubmitForm;
  static e_TypeResetForm;
  static e_TypeImportData;
  static e_TypeJavaScript;
  static e_TypeSetOCGState;
  static e_TypeRendition;
  static e_TypeTrans;
  static e_TypeGoTo3DView;
 
  static e_NewWindowFlagFalse;
  static e_NewWindowFlagTrue;
  static e_NewWindowFlagNone;
 
 
  static Create(document, action_type);
 
  constructor(r);
  constructor(document, action_dict);
 
  IsEmpty();
 
  GetType();
 
  GetDocument();
 
  GetDict();
 
  GetSubActionCount();
 
  GetSubAction(index);
 
  SetSubAction(index, sub_action);
 
  InsertSubAction(index, sub_action);
 
  RemoveSubAction(index);
 
  RemoveAllSubActions();
}
 
export class GotoAction extends Action {
 
  constructor(r);
  constructor(action);
 
  GetDestination();
 
  SetDestination(dest);
}
 
export class URIAction extends Action {
 
  constructor(r);
  constructor(action);
 
  GetURI();
 
  SetURI(uri);
 
  IsTrackPosition();
 
  SetTrackPositionFlag(is_track_position);
}
 
export class JavaScriptAction extends Action {
 
  constructor(r);
  constructor(action);
 
  GetScript();
 
  SetScript(script);
}
 
export class NamedAction extends Action {
 
  constructor(r);
  constructor(action);
 
  GetName();
 
  SetName(name);
}
 
export class RemoteGotoAction extends Action {
 
  constructor(r);
  constructor(action);
 
  GetDestination();
 
  SetDestination(destination);
 
  GetDestinationName();
 
  SetDestinationName(dest_name);
 
  GetFileSpec();
 
  SetFileSpec(file_specification);
 
  GetNewWindowFlag();
 
  SetNewWindowFlag(flag);
}
 
export class EmbeddedGotoAction extends Action {
  constructor(r);
  constructor(action);
 
  GetDestination();
 
  SetDestination(destination);
 
  GetDestinationName();
 
  SetDestinationName(dest_name);
 
  GetRootFile();
 
  SetRootFile(file_specification);
 
  GetNewWindowFlag();
 
  SetNewWindowFlag(flag);
 
  GetTarget();
 
  SetTarget(target);
}
 
export class SubmitFormAction extends Action {
  static e_FlagExclude;
  static e_FlagIncludeNoValueFields;
  static e_FlagExportFormat;
  static e_FlagGetMethod;
  static e_FlagWithCoordinates;
  static e_FlagAsXFDF;
  static e_FlagIncludeAppendSaves;
  static e_FlagIncludeAnnotations;
  static e_FlagSubmitAsPDF;
  static e_FlagCanonicalFormat;
  static e_FlagExclNonUserAnnots;
  static e_FlagExclFKey;
  static e_FlagEmbedForm;
 
  constructor(r);
  constructor(action);
 
  GetURL();
 
  SetURL(url);
 
  GetFieldNames();
 
  SetFieldNames(field_names);
 
  GetFlags();
 
  SetFlags(flags);
}
 
export class ResetFormAction extends Action {
  constructor(r);
  constructor(action);
 
  GetFieldNames();
 
  SetFieldNames(field_names);
 
  GetFlags();
 
  SetFlags(flags);
}
 
export class ImportDataAction extends Action {
  constructor(r);
  constructor(action);
 
  GetFDFFileSpec();
 
  SetFDFFileSpec(file_specification);
}
 
export class HideAction extends Action {
  constructor(r);
  constructor(action);
 
  GetFieldNames();
 
  SetFieldNames(field_names);
 
  GetHideState();
 
  SetHideState(is_hide);
}
 
export class LaunchAction extends Action {
  constructor(r);
  constructor(action);
 
  GetFileSpec();
 
  SetFileSpec(file_specification);
 
  GetNewWindowFlag();
 
  SetNewWindowFlag(flag);
 
  GetWinFileName();
 
  GetWinDefaultDirectory();
 
  GetWinAppOperation();
 
  GetWinAppParameter();
 
  SetWinLaunchParameter(file_name, default_directory,
    operation, app_parameter);
}
 
export class RenditionAction extends Action {
  static e_OpTypeNone;
  static e_OpTypeAssociate;
  static e_OpTypeStop;
  e_OpTypePause;
  e_OpTypeResume;
  e_OpTypePlay;
 
  constructor(r);
  constructor(action);
 
  GetOperationType();
 
  SetOperationType(op_type);
 
  GetRenditionCount();
 
  GetRendition(index);
 
  InsertRendition(rendition, index);
 
  RemoveRendition(rendition);
 
  GetScreenAnnot();
 
  SetScreenAnnot(screen_annot);
 
  GetJavaScript();
 
  SetJavaScript(script);
}
 
export class AdditionalAction extends NativeObjectWrapper {
  static e_TriggerPageOpened;
  static e_TriggerPageClosed;
  static e_TriggerDocWillClose;
  static e_TriggerDocWillSave;
  static e_TriggerDocSaved;
  static e_TriggerDocWillPrint;
  static e_TriggerDocPrinted;
  static e_TriggerFieldKeyStroke;
  static e_TriggerFieldWillFormat;
  static e_TriggerFieldValueChanged;
  static e_TriggerFieldRecalculateValue;
  static e_TriggerAnnotCursorEnter;
  static e_TriggerAnnotCursorExit;
  static e_TriggerAnnotMouseButtonPressed;
  static e_TriggerAnnotMouseButtonReleased;
  static e_TriggerAnnotReceiveInputFocus;
  static e_TriggerAnnotLoseInputFocus;
  static e_TriggerAnnotPageOpened;
  static e_TriggerAnnotPageClosed;
  static e_TriggerAnnotPageVisible;
  static e_TriggerAnnotPageInvisible;
 
  constructor(r);
  constructor(doc, pdf_dict);
 
  constructor(page);
 
  constructor(field);
 
  constructor(annot);
 
  IsEmpty();
 
  GetAction(trigger);
 
  SetAction(trigger, action);
 
  RemoveAction(trigger);
 
  RemoveAllActions();
 
  DoJSAction(trigger);
 
  GetDict();
}
 
export class EmbeddedGotoTarget extends NativeObjectWrapper {
  constructor(r);
  constructor(document);
 
  constructor(document, target_object);
 
  GetDict();
 
  IsEmpty();
 
  GetRelationship();
 
  SetRelationship(relationship);
 
  GetAttachedFileName();
 
  SetAttachedFileName(embed_file_name);
 
  GetPageIndex();
 
  SetPageIndex(page_index);
 
  GetFileAttachmentAnnotIndex();
 
  SetFileAttachmentAnnotIndex(annot_index);
 
  GetTarget();
 
  SetTarget(target);
}
 
export class SetOCGStateAction extends NativeObjectWrapper {
  static e_OCGStateOn;
  static e_OCGStateOff;
  static e_OCGStateToggle;
 
  constructor(action);
 
  GetOCGStateCount();
 
  GetOCGState(index);
 
  GetOCGStateArray(index);
 
  InsertOCGStates(document, index, state, ocg_dict_array);
 
  ReplaceOCGStates(document, index, ocg_dict_array);
 
  RemoveOCGStates(index);
 
  IsRadioButtonStatePreserved();
 
  SetRadioButtonStatePreserved(is_preserved);
}
// End of /Users/ec2-user/gitlab-runner/builds/E-xKdhDoq/0/foxit/sdk/mobile/harmonyrdk/script/../foxit_rdk/src/main/cpp/types/libfoxit_rdk_native/pdf/actions/actions.d.ts
// Start of /Users/ec2-user/gitlab-runner/builds/E-xKdhDoq/0/foxit/sdk/mobile/harmonyrdk/script/../foxit_rdk/src/main/cpp/types/libfoxit_rdk_native/pdf/graphics/graphics.d.ts
 
export class GraphicsObjectArray extends NativeObjectWrapper {
  constructor(r);
  constructor();
 
  GetSize();
 
  GetUpperBound();
 
  SetSize(nNewSize, nGrowBy);
 
  RemoveAll();
 
  GetAt(nIndex);
 
  SetAt(nIndex, newElement);
 
  SetAtGrow(nIndex, newElement);
 
 
  Add(newElement);
 
  InsertAt(nIndex, newElement, nCount);
 
  RemoveAt(nIndex, nCount);
 
  InsertAt(nStartIndex, pNewArray);
 
  Find(data, iStart);
}
 
export class TextObjectArray extends NativeObjectWrapper {
  constructor();
 
  GetSize();
 
  GetUpperBound();
 
  SetSize(nNewSize, nGrowBy);
 
  RemoveAll();
 
  GetAt(nIndex);
 
  SetAt(nIndex, newElement);
 
  SetAtGrow(nIndex, newElement);
 
 
  Add(newElement);
 
  InsertAt(nIndex, newElement, nCount);
 
  RemoveAt(nIndex, nCount);
 
  InsertAt(nStartIndex, pNewArray);
 
  Find(data, iStart);
}
 
export class ColorState extends NativeObjectWrapper {
  IsEmpty();
 
  GetFillColor();
 
  SetFillColor(color);
 
  GetStrokeColor();
 
  SetStrokeColor(color);
}
 
export class MarkedContent extends NativeObjectWrapper {
  HasTag(tag_name);
 
  GetItemCount();
 
  GetItemTagName(index);
 
  GetItemMCID(index);
 
  GetItemPropertyDict(index);
 
  AddItem(tag_name, property_dict);
 
  RemoveItem(tag_name);
}
 
export class GraphicsObject extends NativeObjectWrapper {
  static e_BlendNormal;
  static e_BlendMultiply;
  static e_BlendScreen;
  static e_BlendOverlay;
  static e_BlendDarken;
  static e_BlendLighten;
  static e_BlendColorDodge;
  static e_BlendColorBurn;
  static e_BlendHardlight;
  static e_BlendSoftlight;
  static e_BlendDifference;
  static e_BlendExclusion;
  static e_BlendHue;
  static e_BlendSaturation;
  static e_BlendColor;
  static e_BlendLuminosity;
 
 
  static e_TypeAll;
  static e_TypeText;
  static e_TypePath;
  static e_TypeImage;
  static e_TypeShading;
  static e_TypeFormXObject;
  static e_TypeInlines;
  static e_TypeEmptyMarkedContent;
 
 
  Release();
 
 
  GetType();
 
  GetRect();
 
  HasTransparency();
 
  GetStrokeColor();
 
  GetFillColor();
 
  SetStrokeColor(color);
 
  SetFillColor(color);
 
  GetColorState();
 
  SetColorState(color_state);
 
  SetFillOpacity(opacity);
 
  SetStrokeOpacity(opacity);
 
  GetFillOpacity();
 
  GetStrokeOpacity();
 
  GetMatrix();
 
  SetMatrix(matrix);
 
  Transform(matrix, need_transform_clippath);
 
  Clone();
 
  Clone(src_graphicsobjects, dest_graphicsobjects);
 
  GetGraphState();
 
  SetGraphState(graph_state);
 
  GetBlendMode();
 
  SetBlendMode(blend_mode);
 
  GetClipPathCount();
 
  GetClipPath(index);
 
  GetClipPathFillMode(index);
 
  AddClipPath(path, fill_mode);
 
  RemoveClipPath(index);
 
  GetClipTextObjectCount();
 
  GetClipTextObject(index);
 
  AddClipTextObject(textobject);
 
  RemoveClipTextObject(index);
 
  GetClipRect();
 
  SetClipRect(clip_rect);
 
  ClearClips();
 
  GetMarkedContent();
 
  GetLayers(layer_tree);
 
  GetTextObject();
 
  GetFormXObject();
 
  GetImageObject();
 
  GetPathObject();
 
  GetShadingObject();
 
  Rotate(angle);
}
 
//typedef CFX_ArrayTemplate < GraphicsObject *> GraphicsObjectArray;
 
 
export class TextState extends NativeObjectWrapper {
  static e_ModeFill;
  static e_ModeStroke;
  static e_ModeFillStroke;
  static e_ModeInvisible;
  static e_ModeFillClip;
  static e_ModeStrokeClip;
  static e_ModeFillStrokeClip;
  static e_ModeClip;
 
  constructor(r);
  constructor(version, font, font_size, charspace, wordspace, textmode,
    origin_position, textmatrix[]);
 
  constructor();
 
  Set(version, font, font_size, charspace, wordspace, textmode,
    origin_position, textmatrix[]);
 
 
  version;
 
  font;
 
  font_size;
 
  font_vertical_size;
 
  font_horizontal_size;
 
  charspace;
 
  wordspace;
 
  textmode;
 
  origin_position;
 
  textmatrix[];
}
 
export class ImageObject extends GraphicsObject {
  static Create(document);
 
  SetBitmap(bitmap, mask);
 
  SetImage(image, frame_index);
 
  CloneBitmap(graphics_objects);
 
  CloneBitmap(page, graphics_objects);
 
  GetColorSpace();
 
  GetStream();
 
  IsImageMask();
 
  GetMask();
}
 
export class TextObject extends GraphicsObject {
  static Create();
 
  GetText();
 
  SetText(text);
 
  SetText(text);
 
  GetTextState(page);
 
  SetTextState(page, text_state, is_italic, weight);
 
  GetCharCount();
 
  GetCharPos(index);
 
  GetCharWidthByIndex(index);
 
  GetCharHeightByIndex(index);
}
 
export class PathObject extends GraphicsObject {
  static Create();
 
  static CreateFromTextObject(page, text_obj);
 
  GetFillMode();
 
  SetFillMode(fill_mode);
 
  GetStrokeState();
 
  SetStrokeState(is_stroke);
 
  GetPathData();
 
  SetPathData(path_data);
}
 
export class FormXObject extends GraphicsObject {
  static Create(document);
 
  GetStream();
 
  GetGraphicsObjects();
 
  ImportPageContent(source_page, is_annots_included);
}
 
export class ShadingObject extends GraphicsObject {
  GetPDFObject();
}
// End of /Users/ec2-user/gitlab-runner/builds/E-xKdhDoq/0/foxit/sdk/mobile/harmonyrdk/script/../foxit_rdk/src/main/cpp/types/libfoxit_rdk_native/pdf/graphics/graphics.d.ts
// Start of /Users/ec2-user/gitlab-runner/builds/E-xKdhDoq/0/foxit/sdk/mobile/harmonyrdk/script/../foxit_rdk/src/main/cpp/types/libfoxit_rdk_native/common/basictypes.d.ts
 
export class WStringArray extends NativeObjectWrapper {
 
  constructor(r);
  constructor();
 
  GetSize();
 
  GetAt(index);
 
  Add(element);
 
  RemoveAt(index);
 
  InsertAt(index, element);
 
  RemoveAll();
}
 
export class StringArray extends NativeObjectWrapper {
 
  constructor(r);
  constructor();
 
  GetSize();
 
  GetAt(index);
 
  Add(element);
 
  RemoveAt(index);
 
  InsertAt(index, element);
 
  RemoveAll();
}
 
export class DateTime {
  static GetUTCTime();
 
  static GetLocalTime();
 
  constructor(r);
  constructor(year, month, day,
    hour, minute, second, milliseconds,
    utc_hour_offset, utc_minute_offset);
 
  constructor();
 
  Set(year, month, day,
    hour, minute, second, milliseconds,
    utc_hour_offset, utc_minute_offset);
 
 
  IsValid();
 
 
  ToLocalTime();
 
  ToUTCTime();;
 
  year;
  month;
  day;
  hour;
  minute;
  second;
  milliseconds;
  utc_hour_offset;
  utc_minute_offset;
}
// End of /Users/ec2-user/gitlab-runner/builds/E-xKdhDoq/0/foxit/sdk/mobile/harmonyrdk/script/../foxit_rdk/src/main/cpp/types/libfoxit_rdk_native/common/basictypes.d.ts
// Start of /Users/ec2-user/gitlab-runner/builds/E-xKdhDoq/0/foxit/sdk/mobile/harmonyrdk/script/../foxit_rdk/src/main/cpp/types/libfoxit_rdk_native/common/common.d.ts
 
 
export const e_ErrSuccess
export const e_ErrFile
export const e_ErrFormat
export const e_ErrPassword
export const e_ErrHandle
export const e_ErrCertificate
export const e_ErrUnknown
export const e_ErrInvalidLicense
export const e_ErrParam
export const e_ErrUnsupported
export const e_ErrOutOfMemory
export const e_ErrSecurityHandler
export const e_ErrNotParsed
export const e_ErrNotFound
export const e_ErrInvalidType
export const e_ErrConflict
export const e_ErrUnknownState
export const e_ErrDataNotReady
export const e_ErrInvalidData
export const e_ErrXFALoadError
export const e_ErrNotLoaded
export const e_ErrInvalidState
export const e_ErrNotCDRM
export const e_ErrCanNotConnectToServer
export const e_ErrInvalidUserToken
export const e_ErrNoRights
export const e_ErrRightsExpired
export const e_ErrDeviceLimitation
export const e_ErrCanNotRemoveSecurityFromServer
export const e_ErrCanNotGetACL
export const e_ErrCanNotSetACL
export const e_ErrIsAlreadyCPDF
export const e_ErrIsAlreadyCDRM
export const e_ErrCanNotUploadDocInfo
export const e_ErrCanNotUploadCDRMInfo
export const e_ErrInvalidWrapper
export const e_ErrCanNotGetClientID
export const e_ErrCanNotGetUserToken
export const e_ErrInvalidACL
export const e_ErrInvalidClientID
export const e_ErrOCREngineNotInit
export const e_ErrDiskFull
export const e_ErrOCRTrialIsEnd
export const e_ErrFilePathNotExist
export const e_ErrComplianceEngineNotInit
export const e_ErrComplianceEngineInvalidUnlockCode
export const e_ErrComplianceEngineInitFailed
export const e_ErrTimeStampServerMgrNotInit
export const e_ErrLTVVerifyModeNotSet
export const e_ErrLTVRevocationCallbackNotSet
export const e_ErrLTVCannotSwitchVersion
export const e_ErrLTVCannotCheckDTS
export const e_ErrLTVCannotLoadDSS
export const e_ErrLTVCannotLoadDTS
export const e_ErrNeedSigned
export const e_ErrComplianceResourceFile
export const e_ErrTimeStampServerMgrNoDefaltServer
export const e_ErrDefaultTimeStampServer
export const e_ErrNoConnectedPDFModuleRight
export const e_ErrNoXFAModuleRight
export const e_ErrNoRedactionModuleRight
export const e_ErrNoRMSModuleRight
export const e_ErrNoOCRModuleRight
export const e_ErrNoComparisonModuleRight
export const e_ErrNoComplianceModuleRight
export const e_ErrNoOptimizerModuleRight
export const e_ErrNoConversionModuleRight
export const e_ErrOfficeComNotInit
export const e_ErrNoMicroOfficeInstalled
export const e_ErrExcelHasNoContent
export const e_ErrNoLayoutRecognitionModuleRight
export const e_ErrWPSEngineNotFound
export const e_ErrLibreofficeEngineNotFound
export const e_ErrNoAccessibilityModuleRight
export const e_ErrODAEngineNotFound
export const e_ErrNoTableMakerModuleRight
export const e_ErrNoDWG2PDFModuleRight
export const e_ErrNoAdvEditModuleRight
export const e_ErrNoPDF2OfficeModuleRight
export const e_ErrURLInBlackList
export const e_ErrOFDEngineNotInit
export const e_ErrNoOFDModuleRight;
export const e_ErrNo3DModuleRight;
export const e_ErrInvalidRegex;
export const e_ErrNoDocumentPermission;
export const e_ErrNoOffice2PDFModuleRight;
export const e_ErrMIPUPEEngineInitFailed;
export const e_ErrMIPProtectionEngineInitFailed;
export const e_ErrMIPCreateProtectionHandlerFailed;
export const e_ErrMIPGetExtendedLabelInfoByIdFailed;
export const e_ErrNoPrint2PDFModuleRight;
export const e_ErrResponseDataError;
export const e_ErrTimeout;
export const e_ErrNoImageObject;
export const e_ErrFXOCREngineNotInit;
 
 
export const e_Rotation0;
export const e_Rotation90;
export const e_Rotation180;
export const e_Rotation270;
export const e_RotationUnknown;
 
 
export const e_AlignmentLeft;
export const e_AlignmentCenter;
export const e_AlignmentRight;
 
export const e_FillModeNone;
export const e_FillModeAlternate;
export const e_FillModeWinding;
 
export const e_PosTopLeft;
export const e_PosTopCenter;
export const e_PosTopRight;
export const e_PosCenterLeft;
export const e_PosCenter;
export const e_PosCenterRight;
export const e_PosBottomLeft;
export const e_PosBottomCenter;
export const e_PosBottomRight;
 
 
 
export const e_ModuleNameConnectedPDF;
export const e_ModuleNameXFA;
export const e_ModuleNameRedaction;
export const e_ModuleNameRMS;
export const e_ModuleNameOCR;
export const e_ModuleNameComparison;
export const e_ModuleNameCompliance;
export const e_ModuleNameOptimizer;
export const e_ModuleNameConversion;
export const e_ModuleNameLayoutRecognition;
export const e_ModuleNameAccessibility;
export const e_ModuleNameTableMaker;
export const e_ModuleNameDWG2PDF;
export const e_ModuleNameAdvEdit;
export const e_ModuleNamePDF2Office;
 
 
export const e_ColorSpaceInvalid;
export const e_ColorSpaceDeviceGray;
export const e_ColorSpaceDeviceRGB;
export const e_ColorSpaceDeviceCMYK;
export const e_ColorSpaceCalGray;
export const e_ColorSpaceCalRGB;
export const e_ColorSpaceLab;
export const e_ColorSpaceSeparation;
export const e_ColorSpaceDeviceN;
export const e_ColorSpacePattern;
export const e_ColorSpaceICCBasedDeviceGray;
export const e_ColorSpaceICCBasedDeviceRGB;
export const e_ColorSpaceICCBasedDeviceCMYK;
 
 
export const e_LocaleIDUnspecified;
export const e_LocaleIDHongKong;
export const e_LocaleIDTaiwan;
export const e_LocaleIDNetherlands;
export const e_LocaleIDFrance;
export const e_LocaleIDGermany;
export const e_LocaleIDItaly;
export const e_LocaleIDKorea;
export const e_LocaleIDJapan;
 
 
export const e_FileFormatTypeFDF;
export const e_FileFormatTypeXFDF;
export const e_FileFormatTypeHTML;
export const e_FileFormatTypeXDP;
export const e_FileFormatTypeXML;
export const e_FileFormatTypeXFD;
export const e_FileFormatTypePDF;
export const e_FileFormatTypeTXT;
 
 
export class Codec extends NativeObjectWrapper {
  static Base64Encode(data_buffer, length);
 
  static Base64Decode(encoded_data_buffer, length);
 
  static FlateCompress(data_buffer, length);
 
  static FlateDecompress(compressed_data_buffer, length);
}
 
export class INotifierCallback {
  Release();
 
  OnOutOfMemory();
}
 
export class Progressive extends NativeObjectWrapper {
  static e_Error;
  static e_ToBeContinued;
  static e_Finished;
 
  Continue();
 
  GetRateOfProgress();
}
 
 
export class RenderConfig extends NativeObjectWrapper {
  constructor(r);
  constructor(graphics_objs_count_in_one_step);
 
  constructor();
 
 
  Set(graphics_objs_count_in_one_step);
 
  graphics_objs_count_in_one_step;
}
 
 
export class Library extends NativeObjectWrapper {
  static Initialize(sn, key);
 
  static Reinitialize();
 
  static Release();
 
  static HasModuleLicenseRight(module_name);
 
  static GetVersion();
 
  static SetCacheSize(size);
 
  static EnableJavaScript(enable_javascript);
 
 
  static SetAnnotIconProviderCallback(annot_icon_provider);
 
  static SetNotifierCallback(notifier);
 
  static SetActionCallback(action_callback);
 
  static SetDocEventCallback(callback);
 
  static RegisterSignatureCallback(filter, sub_filter,
    signature_callback);
 
  static UnregisterSignatureCallback(filter, sub_filter);
 
  static RegisterSecurityCallback(filter, callback);
 
  static UnregisterSecurityCallback(filter);
 
  static SetTimeStampCallback(timestamp_callback);
 
 
  static RegisterXFAAppProviderCallback(callback);
 
 
  static SetRenderTextGamma(gamma);
 
 
  static SetLogFile(log_file_path);
 
  static SetLogFile(log_file_path);
 
  static SetFontMapperCallback(callback);
 
  static SetDefaultICCProfilesPath(icc_profile_folder_path);
 
  static GetRenderConfig();
 
  static SetRenderConfig(render_config);
 
  static EnableThreadSafety(is_enable_thread_safety);
 
  static InitializeOFDEngine(ofd_library_path);
 
  static ReleaseOFDEngine();
 
  static AddExternalFontPath(font_path);
 
  static MatchExternalFontsOnly(only_match);
}
 
 
export class GraphState extends NativeObjectWrapper {
  static e_LineCapButt;
  static e_LineCapRound;
  static e_LineCapSquare;
 
 
  static e_LineJoinMiter;
  static e_LineJoinRound;
  static e_LineJoinBevel;
 
  constructor(r);
  constructor(line_width, line_join, miter_limit,
    line_cap, dash_phase, dashes)
 
  
  constructor()
 
  
  Set(line_width, line_join, miter_limit,
    line_cap, dash_phase, dashes);
 
 
  line_width;
  line_join;
  miter_limit;
  line_cap;
 
  dash_phase;
 
  dashes;
}
 
 
export class Range extends NativeObjectWrapper {
  static e_All;
  static e_Even;
  static e_Odd;
 
  constructor(r);
  constructor();
 
  constructor(index);
 
  constructor(start_index, end_index, filter);
 
  IsEmpty();
 
  AddSingle(index);
 
  AddSegment(start_index, end_index, filter);
 
  GetSegmentCount();
 
  GetSegmentStart(segment_index);
 
  GetSegmentEnd(segment_index);
 
  RemoveAll();
 
  // User is strongly recommended NOT to use this method; otherwise unknown situation may occur.
 
}
 
 
export class Font extends NativeObjectWrapper {
  static e_StyleFixedPitch;
  static e_StyleSerif;
  static e_StyleSymbolic;
  static e_StyleScript;
  static e_StyleNonSymbolic;
  static e_StyleItalic;
  static e_StyleAllCap;
  static e_StylesSmallCap;
  static e_StylesBold;
 
 
  static e_CharsetANSI;
  static e_CharsetDefault;
  static e_CharsetSymbol;
  static e_CharsetShift_JIS;
  static e_CharsetHangeul;
  static e_CharsetGB2312;
  static e_CharsetChineseBig5;
  static e_CharsetThai;
  static e_CharsetEastEurope;
  static e_CharsetRussian;
  static e_CharsetGreek;
  static e_CharsetTurkish;
  static e_CharsetHebrew;
  static e_CharsetArabic;
  static e_CharsetBaltic;
 
 
  static e_CIDCharsetUnknown;
  static e_CIDCharsetGB1;
  static e_CIDCharsetCNS1;
  static e_CIDCharsetJAPAN1;
  static e_CIDCharsetKOREA1;
  static e_CIDCharsetUNICODE;
 
 
  static e_StdIDCourier;
  static e_StdIDCourierB;
  static e_StdIDCourierBI;
  static e_StdIDCourierI;
  static e_StdIDHelvetica;
  static e_StdIDHelveticaB;
  static e_StdIDHelveticaBI;
  static e_StdIDHelveticaI;
  static e_StdIDTimes;
  static e_StdIDTimesB;
  static e_StdIDTimesBI;
  static e_StdIDTimesI;
  static e_StdIDSymbol;
  static e_StdIDZapfDingbats;
 
 
  static e_FontTypeType1;
  static e_FontTypeTrueType;
  static e_FontTypeType3;
  static e_FontTypeCIDFont;
 
  constructor(r);
  constructor(name, styles, charset, weight);
 
  constructor(font_id);
 
  constructor(font_file_path, face_index, charset);
 
  constructor(stream);
 
  IsEmpty();
 
  GetName();
 
  GetFamilyName();
 
  IsBold();
 
  IsItalic();
 
  IsEmbedded(document);
 
  IsSupportEmbedded(document);
 
  Embed(document, is_add_all_unicodes);
 
  AddUnicodes(document, unicode_array);
 
 
  GetAscent();
 
  GetDescent();;
 
  GetCharBBox(unicode);
 
  GetCharWidth(unicode);
 
  GetCharBBox(unicode, document);
 
  GetCharWidth(unicode, document);
 
  GetStyles(document);
 
  GetCIDCharset(document);
 
  IsStandardFont(document);
 
  GetStandard14Font(document);
 
  GetFontType(document);
 
  GetBaseFontName(document);
 
  IsVertWriting(document);
 
  GetEncoding(document);
 
  SetEncoding(document, value);
 
  IsCharSupported(unicode, document);
}
 
export class FontMapResult extends NativeObjectWrapper {
  constructor(r);
  constructor();
 
  constructor(file_read, face_index);
 
  Set(file_read, face_index);
 
  file_read;
  face_index;
}
 
export class IFontMapperCallback {
  Release();
 
  MapFont(font_name, is_truetype, styles,
    weight, italic_angle, charset);
}
 
 
export class Path extends NativeObjectWrapper {
  static e_TypeMoveTo;
  static e_TypeLineTo;
  static e_TypeLineToCloseFigure;
  static e_TypeBezierTo;
  static e_TypeBezierToCloseFigure;
 
  constructor(r);
  constructor();
 
  IsEmpty();
 
  GetPointCount();
 
  GetPoint(index);
 
  GetPointType(index);
 
  SetPoint(index, point, type);
 
  MoveTo(point);
 
  LineTo(point);
 
  CubicBezierTo(point1, point2, point3);
 
  CloseFigure();
 
  RemovePoint(index);
 
  AppendRect(rect);
 
  AppendEllipse(rect);
 
  Transform(matrix);
 
  Clear();
 
  IncreasePointCount(count);
}
 
 
export class PathArray extends NativeObjectWrapper {
  constructor(r);
  constructor();
 
  GetSize();
 
  GetAt(index);
 
  Add(element);
 
  RemoveAt(index);
 
  InsertAt(index, element);
 
  RemoveAll();
}
 
 
export class ColorSpace extends NativeObjectWrapper {
  static e_RenderIntentPerceptual;
  static e_RenderIntentRelColorimetric;
  static e_RenderIntentSaturation;
  static e_RenderIntentAbsColorimetric;
 
  constructor(r);
  constructor(type);
 
  IsEmpty();
 
  GetComponentCount();
 
  GetColorSpaceType();
 
  IsSpotColorSpace();
 
  GetComponentNames();
 
  ConvertColor(color);
 
  ConvertColor(r_value, g_value, b_value);
 
  ConvertColor(c_value, m_value, y_value, k_value);
}
 
export class Color extends NativeObjectWrapper {
  constructor(r);
  constructor();
 
  constructor(color_space);
 
 
  IsEmpty();
 
  GetColorSpace();
 
  GetValue();
 
  SetValue(component_array);
 
  ConvertToRGB(intent);
 
  ConvertToCMYK(intent);
}
 
export class Bitmap extends NativeObjectWrapper {
  static e_DIBInvalid;
  static e_DIB1bpp;
  static e_DIBRgb;
  static e_DIBRgb32;
  static e_DIBArgb;
  static e_DIBCmyk;
  static e_DIB8bppMask;
  static e_DIB8bpp;
  static e_DIB8bppGray;
  static e_DIBAbgr;
  static e_DIBRgb565;
 
  static e_Downsample;
  static e_Quadratic;
  static e_Bicubic;
 
  static e_EnhanceAlgoGrayLevelTransformation;
 
  static e_ThresholdAlgoFixedThreshold;
  static e_ThresholdAlgoOTSU;
 
  constructor(r);
 
  constructor(width, height, format, buffer, pitch);
 
  constructor();
 
  IsEmpty();
 
  Clone(clip_rect);
 
  GetWidth();
 
  GetHeight();
 
  GetPitch();
 
  GetBpp();
 
  GetBuffer();
 
  GetFormat();
 
  FillRect(color, rect);
 
  FillRectAsync(color, rect);<void>;
 
  ConvertFormat(format, icc_transform);
 
  CalculateBBoxByColor(backgroud_color);
 
  DetectBBoxByColorDiffer(detection_size, color_differ);
 
  SwapXY(is_flip_horz, is_flip_vert, clip_rect);
 
  Flip(is_flip_horz, is_flip_vert);
 
  StretchTo(dest_width, dest_height, flag,
    clip_rect);
 
  TransformTo(matrix, flag,
    out_left, out_top, clip_rect);
 
  GetMask(clip_rect);
 
  ConvertToMono();
 
  FadeOutBackground(enchancement_algorithms, threshold_algorithms, threshold_level);
}
 
export class Image extends NativeObjectWrapper {
 
  static e_OrientationNone;
  static e_OrientationNormal;
  static e_OrientationFlipH;
  static e_OrientationRotate180;
  static e_OrientationFlipV;
  static e_OrientationRotate90FlipH;
  static e_OrientationRotate90;
  static e_OrientationRotate270FlipH;
  static e_OrientationRotate270;
 
  static e_Unknown;
  static e_None;
  static e_BMP;
  static e_JPG;
  static e_PNG;
  static e_GIF;
  static e_TIF;
  static e_JPX;
  static e_JBIG2;
  static e_WEBP;
 
  constructor(r);
  constructor();
 
  constructor(path);
 
  constructor(buffer);
 
  constructor(file_read);
 
 
  IsEmpty();
 
 
  GetType();
 
  GetWidth();
 
  GetHeight();
 
  GetFrameCount();
 
  GetFrameBitmap(index);
 
  GetXDPI();
 
  GetYDPI();
 
  AddFrame(bitmap);
 
  SetDPIs(x_dpi, y_dpi);
 
  SaveAs(file_path);
 
  SaveAs(file, file_extension);
 
  GetOrientation();
}
 
 
export class Renderer extends NativeObjectWrapper {
  static e_ColorModeNormal;
  static e_ColorModeMappingGray;
  static e_ColorModeMapping;
  static e_ColorModeAlpha;
  static e_ColorModeForeground;
 
  static e_RenderPage;
  static e_RenderAnnot;
  static e_RenderHighlight;
  static e_RenderExceptHighlight;
  static e_RenderScreen;
 
  static e_ColorModeForegroundText;
  static e_ColorModeForegroundPath;
  static e_ColorModeForegroundBlackText;
  static e_ColorModeForegroundBlackPath;
 
  constructor(r);
  constructor(bitmap, is_rgb_order);
 
  IsEmpty();
 
  StartQuickRender(page, matrix, pause);
 
  StartRender(page, matrix, pause);
 
  StartRenderAsync(page, matrix, pause);<Progressive>
 
  StartRenderReflowPage(reflow_page, matrix,
    pause);
  StartRenderReflowPageAsync(reflow_page, matrix,
    pause);<Progressive>;
 
  StartRenderXFAPage(xfa_page_view, matrix, is_highlight,
    pause);
  StartRenderXFAPageAsync(xfa_page_view, matrix, is_highlight,
    pause);<Progressive>
 
  StartRenderBitmap(bitmap, matrix,
    clip_rect, interpolation,
    pause);
 
  StartRenderBitmap(bitmap, matrix,
    clip_rect, interpolation,
    alpha, pause);
 
  SetRenderAnnotAppearanceType(ap_type);
 
  RenderAnnot(annot, matrix);
 
  RenderAnnotAsync(annot, matrix);<boolean>;
 
  RenderFormControls(page, matrix);
 
  RenderGraphicsObject(graphics_object, page, matrix);
 
  SetClipRect(clip_rect);
 
  ClearClips();
 
  SetClipPathFill(clip_path, matrix, fill_mode);
 
  SetClipPathStroke(clip_path, matrix, graph_state);
 
  SetRenderContentFlags(render_content_flags);
 
  SetRenderAnnotsForThumbnail(is_render_annots_for_thumbnail);
 
  SetRenderFormField(is_render_formfield);
 
  SetRenderSignature(is_render_signature);
 
  SetLayerContext(layer_context);
 
  SetRenderLayer(is_render_one_layer);
 
  SetColorMode(color_mode);
 
  SetMappingModeColors(background_color, foreground_color);
 
  SetForegroundColorMode(foreground_color_mode);
 
  SetForegroundColor(foreground_color);
 
  SetClearType(is_clear_type);
 
  SetPrintTextAsGraphic(is_to_print_text_graphic);
 
  SetPrintTextAsImage(is_to_print_text_image);
 
  SetForceDownSample(is_to_force_down_sample);
 
  SetOverprint(is_to_enable_overprint);
 
  SetJPEGDownSample(is_jepg_down_sample);
 
  SetJPXDownSample(is_jpx_down_sample);
 
  EnableForPrint(is_render_for_print);
 
  SetForceHalftone(is_to_force_halftone);
 
  SetRenderPathThinLine(is_render_path_thin_line);
 
  SetRenderTextAntiAliasing(is_render_text_antialiasing);
 
  SetRenderPathAntiAliasing(is_render_path_antialiasing);
 
  SetRenderPathFullCovered(is_render_path_full_covered);
 
  SetRenderImageAntiAliasing(is_render_image_antialiasing);
 
  SetRenderEnhanceThinLines(is_render_enhance_thin_lines);
 
  SetRenderSignatureState(is_render_signature_state);
 
  SetRenderInvertBlackWhite(is_render_invert_black_white);
 
  SetRenderBrightness(percent);
 
  TransformRGBAtNight(bitmap, color_light_factor);
 
  DrawTextString(document, text_string, graph_state, origin_x, origin_y,
    font, font_size, matrix, fill_color, stroke_color);
 
  DrawPath(path, graph_state, matrix, fill_color, stroke_color,
    fill_mode, blend_mode);
 
  DrawStrokeRect(path, graph_state, rect, color, width);
 
  SetScreenDPIScale(scale);
}
 
 
export class Barcode extends NativeObjectWrapper {
  static e_FormatCode39;
  static e_FormatCode128;
  static e_FormatEAN8;
  static e_FormatUPCA;
  static e_FormatEAN13;
  static e_FormatITF;
  static e_FormatPDF417;
  static e_FormatQRCode;
 
 
  static e_QRCorrectionLevelLow;
  static e_QRCorrectionLevelMedium;
  static e_QRCorrectionLevelQuater;
  static e_QRCorrectionLevelHigh;
 
  constructor(r);
  constructor();
 
  IsEmpty();
 
  GenerateBitmap(info, format, unit_width, height,
    level);
}
 
export class IPauseCallback {
  NeedToPauseNow();
}
 
 
export class IDocEventCallback {
  Release();
 
  OnDocWillOpen();
 
  OnDocOpened(document, error_code);
 
  OnDocWillDestroy(document);
 
  OnDocWillSave(document);
 
  OnDocSaved(document, error_code);
}
// End of /Users/ec2-user/gitlab-runner/builds/E-xKdhDoq/0/foxit/sdk/mobile/harmonyrdk/script/../foxit_rdk/src/main/cpp/types/libfoxit_rdk_native/common/common.d.ts
// Start of /Users/ec2-user/gitlab-runner/builds/E-xKdhDoq/0/foxit/sdk/mobile/harmonyrdk/script/../foxit_rdk/src/main/cpp/types/libfoxit_rdk_native/common/file/file.d.ts
 
export class IAsyncReaderCallback {
  IsDataAvail(offset, size);
 
  AddDownloadHint(offset, size);
 
  GetSize();
 
  ReadBlock(offset, size);
}
 
export class IReaderCallback {
  Release();
 
  GetSize();
 
  ReadBlock(offset, size);
 
  ReadBlock(buffer, offset, size);
}
 
export class IWriterCallback {
  Release();
 
  GetSize();
 
  Flush();
 
  WriteBlock(pData, offset, size);
}
 
//*****************************************************************************
//* IFX_FileStream
//*****************************************************************************
export class IStreamCallback {
  Retain();
 
  Release();
 
  GetSize();
 
  IsEOF();
 
  GetPosition();
 
  ReadBlock(offset, size);
 
 
  WriteBlock(buffer, offset, size);
 
  Flush();
}
// End of /Users/ec2-user/gitlab-runner/builds/E-xKdhDoq/0/foxit/sdk/mobile/harmonyrdk/script/../foxit_rdk/src/main/cpp/types/libfoxit_rdk_native/common/file/file.d.ts
// Start of /Users/ec2-user/gitlab-runner/builds/E-xKdhDoq/0/foxit/sdk/mobile/harmonyrdk/script/../foxit_rdk/src/main/cpp/types/libfoxit_rdk_native/common/fxcrt/fxcrt.d.ts
 
export class Int32Array extends NativeObjectWrapper {
 
  constructor(r);
  constructor();
 
  GetSize();
 
  GetUpperBound();
 
  SetSize(nNewSize, nGrowBy);
 
  RemoveAll();
 
  GetAt(nIndex);
 
  SetAt(nIndex, newElement);
 
  SetAtGrow(nIndex, newElement);
 
 
  Add(newElement);
 
  InsertAt(nIndex, newElement, nCount);
 
  RemoveAt(nIndex, nCount);
 
  InsertAt(nStartIndex, pNewArray);
 
  Find(data, iStart);
}
 
export class UInt32Array extends NativeObjectWrapper {
 
  constructor(r);
  constructor();
 
  GetSize();
 
  GetUpperBound();
 
  SetSize(nNewSize, nGrowBy);
 
  RemoveAll();
 
  GetAt(nIndex);
 
  SetAt(nIndex, newElement);
 
  SetAtGrow(nIndex, newElement);
 
 
  Add(newElement);
 
  InsertAt(nIndex, newElement, nCount);
 
  RemoveAt(nIndex, nCount);
 
  InsertAt(nStartIndex, pNewArray);
 
  Find(data, iStart);
}
 
export class FloatArray extends NativeObjectWrapper {
 
  constructor(r);
  constructor();
 
  GetSize();
 
  GetUpperBound();
 
  SetSize(nNewSize, nGrowBy);
 
  RemoveAll();
 
  GetAt(nIndex);
 
  SetAt(nIndex, newElement);
 
  SetAtGrow(nIndex, newElement);
 
 
  Add(newElement);
 
  InsertAt(nIndex, newElement, nCount);
 
  RemoveAt(nIndex, nCount);
 
  InsertAt(nStartIndex, pNewArray);
 
  Find(data, iStart);
}
 
export class PointFArray extends NativeObjectWrapper {
 
  constructor(r);
  constructor();
 
  GetSize();
 
  GetUpperBound();
 
  SetSize(nNewSize, nGrowBy);
 
  RemoveAll();
 
  GetAt(nIndex);
 
  SetAt(nIndex, newElement);
 
  SetAtGrow(nIndex, newElement);
 
 
  Add(newElement);
 
  InsertAt(nIndex, newElement, nCount);
 
  RemoveAt(nIndex, nCount);
 
  InsertAt(nStartIndex, pNewArray);
 
  Find(data, iStart);
}
 
export class RectF extends NativeObjectWrapper {
 
  constructor(r);
  constructor();
 
  constructor(left1, bottom1, right1, top1);
 
  IsEmpty();
 
  Normalize();
 
 
  Reset();
 
  Contains(other_rect);
 
  Contains(x, y);
 
  Transform(pMatrix);
 
  Intersect(other_rect);
 
  Union(other_rect);
 
  GetInnerRect();
 
  GetOutterRect();
 
  GetClosestRect();
 
  Substract4(substract_rect, pRects);
 
  InitRect(x, y);
 
  UpdateRect(x, y);
 
  Width();
 
  Height();
 
  Inflate(x, y);
 
  Inflate(left, bottom, right, top,);
 
  Inflate(rt);
 
  Deflate(x, y);
 
  Deflate(left, bottom, right, top,);
 
  Deflate(rt);
 
  Translate(e, f);
 
  static GetBBox(pPoints, nPoints);
 
  left;
  right;
  bottom;
  top;
}
 
export class RectFArray extends NativeObjectWrapper {
 
  constructor(r);
  constructor();
 
  GetSize();
 
 
  GetUpperBound();
 
  SetSize(nNewSize, nGrowBy);
 
  RemoveAll();
 
  GetAt(nIndex);
 
  SetAt(nIndex, newElement);
 
  SetAtGrow(nIndex, newElement);
 
  Add(ewElement);
 
  InsertAt(nIndex, newElement, nCount);
 
  RemoveAt(nIndex, nCount);
 
  InsertAt(nStartIndex, pNewArray);
 
  Find(data, iStart);
}
 
export class RectI extends NativeObjectWrapper {
  left;
  top;
  right;
  bottom;
 
  constructor(r);
 
  constructor();
 
  constructor(left1, top1, right1, bottom1);
 
  Width();
 
  Height();
 
  IsEmpty();
 
  Normalize();
 
  Intersect(src);
 
  Intersect(left1, top1, right1, bottom1);
 
  Union(other_rect);
 
 
  Offset(dx, dy);
 
  Contains(other_rect);
 
  Contains(x, y);
 
  Valid();
}
 
export class Matrix2D extends NativeObjectWrapper {
 
  constructor(r);
  constructor();
 
  constructor(a1, b1, c1, d1, e1, f1);
 
  Set(a, b, c, d, e, f);
 
 
  SetIdentity();
 
  SetReverse(m);
 
  Concat(a, b, c, d, e, f, bPrepended);
 
  Concat(m, bPrepended);
 
  ConcatInverse(m, bPrepended);
 
  Reset();
 
  Copy(m);
 
  IsIdentity();
 
  IsInvertible();
 
  Is90Rotated();
 
  IsScaled();
 
  Translate(x, y, bPrepended);
 
  TranslateI(x, y, bPrepended);
 
  Scale(sx, sy, bPrepended);
 
  Rotate(fRadian, bPrepended);
 
  RotateAt(fRadian, x, y, bPrepended);
 
  Shear(fAlphaRadian, fBetaRadian, bPrepended);
 
  MatchRect(dest, src);
 
  GetXUnit();
 
  GetYUnit();
 
  GetUnitRect();
 
  GetUnitArea();
 
  TransformXDistance(dx);
 
  TransformYDistance(dy);
 
  TransformDistance(dx, dy);
 
  TransformDistance(dx, dy);
 
  TransformDistance(distance);
 
  TransformPoint(x, y);
 
  TransformRect(rect);
 
  TransformRect(rect);
 
  a;
  b;
  c;
  d;
  e;
  f;
}
 
 
export class Point extends NativeObjectWrapper {
 
  constructor(r);
  constructor();
 
  constructor(new_x, new_y);
 
  Set(new_x, new_y);
 
  Set(psv);
 
  Add(x, y);
 
  Subtract(x, y);
 
  Reset();
 
  x;
  y;
}
 
 
 
export class PointF extends NativeObjectWrapper {
 
  constructor(r);
  constructor();
 
  constructor(new_x, new_y);
 
  Set(new_x, new_y);
 
  Set(psv);
 
  Add(x, y);
 
  Subtract(x, y);
 
  Reset();
 
  x;
  y;
}
// End of /Users/ec2-user/gitlab-runner/builds/E-xKdhDoq/0/foxit/sdk/mobile/harmonyrdk/script/../foxit_rdk/src/main/cpp/types/libfoxit_rdk_native/common/fxcrt/fxcrt.d.ts
// Start of /Users/ec2-user/gitlab-runner/builds/E-xKdhDoq/0/foxit/sdk/mobile/harmonyrdk/script/../foxit_rdk/src/main/cpp/types/libfoxit_rdk_native/addon/redaction.d.ts
 
export class IApplyRedactionCallback {
  Release();
 
  NeedToGenerateStreamFile();
}
 
export class Redaction extends NativeObjectWrapper {
 
  constructor(r);
  constructor(document);
 
  IsEmpty();
 
  MarkRedactAnnot(page, rects);
 
  EnableFileStream(temp_directory_path, apply_redaction_callback);
 
  Apply();
 
  StartApply(pause);
  StartApplyAsync(pause);<Progressive>;
}
// End of /Users/ec2-user/gitlab-runner/builds/E-xKdhDoq/0/foxit/sdk/mobile/harmonyrdk/script/../foxit_rdk/src/main/cpp/types/libfoxit_rdk_native/addon/redaction.d.ts
// Start of /Users/ec2-user/gitlab-runner/builds/E-xKdhDoq/0/foxit/sdk/mobile/harmonyrdk/script/../foxit_rdk/src/main/cpp/types/libfoxit_rdk_native/addon/xfa/xfa.d.ts
import { WStringArray } from "../../common/basictypes";
 
export class WidgetChoiceOption extends NativeObjectWrapper {
 
  constructor(r);
  constructor();
 
  constructor(option_label, selected);
 
  Set(option_label, selected);
 
  option_label;
 
  selected;
}
 
export class WidgetChoiceOptionArray extends NativeObjectWrapper {
 
  constructor(r);
  constructor();
 
  GetSize();
 
  GetAt(index);
 
  Add(element);
 
  RemoveAt(index);
 
  InsertAt(index, element);
 
  RemoveAll();
}
 
export class XFADoc extends NativeObjectWrapper {
  static e_EventTypeUnknown;
  static e_EventTypePostPrint;
  static e_EventTypePrePrint;
  static e_EventTypeClick;
  static e_EventTypeChange;
  static e_EventTypeDocClose;
  static e_EventTypeDocReady;
  static e_EventTypeEnter;
  static e_EventTypeExit;
  static e_EventTypeFull;
  static e_EventTypeIndexChange;
  static e_EventTypeInitialize;
  static e_EventTypeMouseDown;
  static e_EventTypeMouseEnter;
  static e_EventTypeMouseExit;
  static e_EventTypeMouseUp;
  static e_EventTypePostExecute;
  static e_EventTypePostOpen;
  static e_EventTypePostSave;
  static e_EventTypePostSign;
  static e_EventTypePostSubmit;
  static e_EventTypePreExecute;
  static e_EventTypePreOpen;
  static e_EventTypePreSave;
  static e_EventTypePreSign;
  static e_EventTypePreSubmit;
  static e_EventTypeReady;
  static e_EventTypeValidationState;
  static e_EventTypeInitCalculate;
  static e_EventTypeInitVariables;
  static e_EventTypeCalculate;
  static e_EventTypeValidate;
 
  static e_Dynamic;
  static e_Static;
  static e_XDP;
 
 
  static e_ExportDataTypeXML;
  static e_ExportDataTypeStaticXDP;
  static e_ExportDataTypeXDP;
 
  constructor(r);
  constructor(document, xfa_doc_provider_handler);
 
  constructor(document);
 
  constructor(other);
 
  XFADoc(document);
 
  IsEmpty();
 
 
  StartLoad(pause);
 
  SetDocProviderCallback(doc_provider_callback);
 
  GetType();
 
  GetPageCount();
 
  GetPage(page_index);
  GetPageAsync(page_index);<XFAPage>;
 
  ExportData(output_file_path, export_type);
 
  ExportData(stream, export_type);
 
  ExportData(output_file_path, export_type);
 
  SetPDFPath(pdf_file_path);
 
  SetPDFPath(pdf_file_path);
 
  ImportData(file_path);
 
  ImportData(file_path);
 
  ImportData(file_reader);
 
  ResetForm();
 
  FlattenTo(output_file_path);
 
  FlattenTo(output_file_path);
 
  FlattenTo(stream);
 
  ProcessEvent(event_type);
 
  SetFocus(xfa_widget);
 
  KillFocus();
 
  GetWidgetByFullName(full_name);
}
 
export class XFAPage extends NativeObjectWrapper {
  IsEmpty();
 
  GetDisplayMatrix(left, top, width, height, rotate);
 
  GetWidth();
 
  GetHeight();
 
  GetWidgetAtDevicePoint(matrix, device_point, tolerance);
 
  GetIndex();
 
  GetWidgetCount();
 
  GetWidget(widget_index);
 
  GetWidgetByFullName(full_name);
 
  GetFirstWidget();
 
  GetLastWidget();
 
  GetNextWidget(widget);
 
  GetPrevWidget(widget);;
}
 
export class XFAWidget extends NativeObjectWrapper {
  static e_HitTestAreaUnknown
  static e_HitTestAreaClient
  static e_HitTestAreaTitleBar
  static e_HitTestAreaHyperLink
 
 
  static e_WidgetTypeBarcode
  static e_WidgetTypePushButton
  static e_WidgetTypeCheckButton
  static e_WidgetTypeArc
  static e_WidgetTypeDateTimeEdit
  static e_WidgetTypeNumericEdit
  static e_WidgetTypeSignature
  static e_WidgetTypeChoiceList
  static e_WidgetTypeImageEdit
  static e_WidgetTypeLine
  static e_WidgetTypePasswordEdit
  static e_WidgetTypeRadioButton
  static e_WidgetTypeRectangle
  static e_WidgetTypeTextEdit
  static e_WidgetTypeUnknown
  static e_WidgetTypeExclGroup
  static e_WidgetTypeImage
 
 
  static e_PresenceUnknown
  static e_PresenceVisible
  static e_PresenceHidden
  static e_PresenceInactive
  static e_PresenceInvisible
 
 
  static e_WidgetNameTypeField
  static e_WidgetNameTypeCaption
  static e_WidgetNameTypeFullName
 
 
  static e_WidgethAlignTypeCenter
  static e_WidgethAlignTypeJustify
  static e_WidgethAlignTypeJustifyAll
  static e_WidgethAlignTypeLeft
  static e_WidgethAlignTypeRadix
  static e_WidgethAlignTypeRight
 
  static e_WidgetvAlignTypeTop
  static e_WidgetvAlignTypeBottom
  static e_WidgetvAlignTypeMiddle
 
  static e_WidgetEdgePositionTop
  static e_WidgetEdgePositionRight
  static e_WidgetEdgePositionBottom
  static e_WidgetEdgePositionLeft
 
  IsEmpty();
 
  GetXFAPage();
 
  GetIndex();
 
  ResetData();
 
  GetRect();
 
  GetValue();
 
  SetValue(value);
 
  GetDefaultValue();
 
  SetDefaultValue(value);
 
  GetName(type);
 
  GetOptions();
 
  IsChecked();
 
  SetCheckState(is_checked);
 
  IsListBox();
 
  IsSupportMultiline();
 
  IsSupportMultiSelect();
 
  GetPresence();
 
  OnMouseEnter();
 
  OnMouseExit();
 
  OnLButtonDown(point, flags);
  OnLButtonDownAsync(point, flags);<boolean>;
 
  OnLButtonUp(point, flags);
  OnLButtonUpAsync(point, flags);<boolean>;
 
  OnLButtonDoubleClick(point, flags);
 
  OnMouseMove(point, flags);
  OnMouseMoveAsync(point, flags);<boolean>;
 
  OnRButtonDown(point, flags);
  OnRButtonDownAsync(point, flags);<boolean>;
 
  OnRButtonUp(point, flags);
  OnRButtonUpAsync(point, flags);<boolean>;
 
  OnKeyDown(key_code, flags);
 
  OnKeyUp(key_code, flags);
 
  OnChar(input_char, flags);
 
  OnHitTest(point);
 
  GetType();
 
  GetHAlign();
 
  GetVAlign();
 
  HasEdge(edge_pos);
 
  GetSignature();
 
  GetToolTip();
 
  GetBitmap();
 
  SetImage(image);
 
  IsAllowRichText();
 
  IsReadOnly();
 
  IsRequired();
 
  ValidateValue(value, format);
 
  GetJavaScript();
 
  GetXMLContent();
}
 
export class WidgetMenu extends NativeObjectWrapper {
  constructor(r);
  constructor(xfa_widget);
 
 
  IsEmpty();
 
  CanCopy();
 
  CanCut();
 
  CanPaste();
 
  CanSelectAll();
 
  CanDelete();
 
  CanDeSelect();
 
  Copy();
 
  Cut();
 
  Paste(text);
 
  SelectAll();
 
  DeleteMenu();
 
  DeSelect();
 
  CanUndo();
 
  CanRedo();
 
  Undo();
 
  Redo();
 
  Bold();
 
  Italic();
 
  Underline();
 
  Superscript();
 
  Subscript();
 
  ClearStyle();
}
 
export namespace DocProviderCallback {
  export const e_InvalidateFlagAllPages;
  export const e_InvalidateFlagCurrentPage;
 
  export const e_PrintOptionShowDialog;
  export const e_PrintOptionCanCancel;
  export const e_PrintOptionShrinkPage;
  export const e_PrintOptionAsImage;
  export const e_PrintOptionReverseOrder;
  export const e_PrintOptionPrintAnnot;
 
 
  export const e_SubmitInXDP;
  export const e_SubmitInPDF;
  export const e_SubmitInUrlEncoded;
  export const e_SubmitInXFD;
  export const e_SubmitInXML;
 
 
  export const e_TextEncodingNone;
  export const e_TextEncodingBig5;
  export const e_TextEncodingFontSpecific;
  export const e_TextEncodingGBK;
  export const e_TextEncodingGB18030;
  export const e_TextEncodingGB2312;
  export const e_TextEncodingISO8859NN;
  export const e_TextEncodingKSC5601;
  export const e_TextEncodingShiftJIS;
  export const e_TextEncodingUCS2;
  export const e_TextEncodingUTF16;
  export const e_TextEncodingUTF8;
 
 
  export const e_PageViewEventTypeAdded;
  export const e_PageViewEventTypeRemoved;
  export const e_PageViewEventTypeAllRemoved;
 
 
  export const e_WidgetEventTypeAdded;
  export const e_WidgetEventTypeBeforeRemoved;
}
 
export class XFAWidgetModifyInfo extends NativeObjectWrapper {
  static e_WidgetElementPs;
  static e_WidgetElementTo;
  static e_WidgetElementUi;
  static e_WidgetElementRecordSet;
  static e_WidgetElementSubsetBelow;
  static e_WidgetElementSubformSet;
  static e_WidgetElementAdobeExtensionLevel;
  static e_WidgetElementTypeface;
  static e_WidgetElementBreak;
  static e_WidgetElementFontInfo;
  static e_WidgetElementNumberPattern;
  static e_WidgetElementDynamicRender;
  static e_WidgetElementPrintScaling;
  static e_WidgetElementCheckButton;
  static e_WidgetElementDatePatterns;
  static e_WidgetElementSourceSet;
  static e_WidgetElementAmd;
  static e_WidgetElementArc;
  static e_WidgetElementDay;
  static e_WidgetElementEra;
  static e_WidgetElementJog;
  static e_WidgetElementLog;
  static e_WidgetElementMap;
  static e_WidgetElementMdp;
  static e_WidgetElementBreakBefore;
  static e_WidgetElementOid;
  static e_WidgetElementPcl;
  static e_WidgetElementPdf;
  static e_WidgetElementRef;
  static e_WidgetElementUri;
  static e_WidgetElementXdc;
  static e_WidgetElementXdp;
  static e_WidgetElementXfa;
  static e_WidgetElementXsl;
  static e_WidgetElementZpl;
  static e_WidgetElementCache;
  static e_WidgetElementMargin;
  static e_WidgetElementKeyUsage;
  static e_WidgetElementExclude;
  static e_WidgetElementChoiceList;
  static e_WidgetElementLevel;
  static e_WidgetElementLabelPrinter;
  static e_WidgetElementCalendarSymbols;
  static e_WidgetElementPara;
  static e_WidgetElementPart;
  static e_WidgetElementPdfa;
  static e_WidgetElementFilter;
  static e_WidgetElementPresent;
  static e_WidgetElementPagination;
  static e_WidgetElementEncoding;
  static e_WidgetElementEvent;
  static e_WidgetElementWhitespace;
  static e_WidgetElementDefaultUi;
  static e_WidgetElementDataModel;
  static e_WidgetElementBarcode;
  static e_WidgetElementTimePattern;
  static e_WidgetElementBatchOutput;
  static e_WidgetElementEnforce;
  static e_WidgetElementCurrencySymbols;
  static e_WidgetElementAddSilentPrint;
  static e_WidgetElementRename;
  static e_WidgetElementOperation;
  static e_WidgetElementTypefaces;
  static e_WidgetElementSubjectDNs;
  static e_WidgetElementIssuers;
  static e_WidgetElementSignaturePseudoModel;
  static e_WidgetElementWsdlConnection;
  static e_WidgetElementDebug;
  static e_WidgetElementDelta;
  static e_WidgetElementEraNames;
  static e_WidgetElementModifyAnnots;
  static e_WidgetElementStartNode;
  static e_WidgetElementButton;
  static e_WidgetElementFormat;
  static e_WidgetElementBorder;
  static e_WidgetElementArea;
  static e_WidgetElementHyphenation;
  static e_WidgetElementText;
  static e_WidgetElementTime;
  static e_WidgetElementType;
  static e_WidgetElementOverprint;
  static e_WidgetElementCertificates;
  static e_WidgetElementEncryptionMethods;
  static e_WidgetElementSetProperty;
  static e_WidgetElementPrinterName;
  static e_WidgetElementStartPage;
  static e_WidgetElementPageOffset;
  static e_WidgetElementDateTime;
  static e_WidgetElementComb;
  static e_WidgetElementPattern;
  static e_WidgetElementIfEmpty;
  static e_WidgetElementSuppressBanner;
  static e_WidgetElementOutputBin;
  static e_WidgetElementField;
  static e_WidgetElementAgent;
  static e_WidgetElementOutputXSL;
  static e_WidgetElementAdjustData;
  static e_WidgetElementAutoSave;
  static e_WidgetElementContentArea;
  static e_WidgetElementEventPseudoModel;
  static e_WidgetElementWsdlAddress;
  static e_WidgetElementSolid;
  static e_WidgetElementDateTimeSymbols;
  static e_WidgetElementEncryptionLevel;
  static e_WidgetElementEdge;
  static e_WidgetElementStipple;
  static e_WidgetElementAttributes;
  static e_WidgetElementVersionControl;
  static e_WidgetElementMeridiem;
  static e_WidgetElementExclGroup;
  static e_WidgetElementToolTip;
  static e_WidgetElementCompress;
  static e_WidgetElementReason;
  static e_WidgetElementExecute;
  static e_WidgetElementContentCopy;
  static e_WidgetElementDateTimeEdit;
  static e_WidgetElementConfig;
  static e_WidgetElementImage;
  static e_WidgetElementSharpxHTML;
  static e_WidgetElementNumberOfCopies;
  static e_WidgetElementBehaviorOverride;
  static e_WidgetElementTimeStamp;
  static e_WidgetElementMonth;
  static e_WidgetElementViewerPreferences;
  static e_WidgetElementScriptModel;
  static e_WidgetElementDecimal;
  static e_WidgetElementSubform;
  static e_WidgetElementSelect;
  static e_WidgetElementWindow;
  static e_WidgetElementLocaleSet;
  static e_WidgetElementHandler;
  static e_WidgetElementHostPseudoModel;
  static e_WidgetElementPresence;
  static e_WidgetElementRecord;
  static e_WidgetElementEmbed;
  static e_WidgetElementVersion;
  static e_WidgetElementCommand;
  static e_WidgetElementCopies;
  static e_WidgetElementStaple;
  static e_WidgetElementSubmitFormat;
  static e_WidgetElementBoolean;
  static e_WidgetElementMessage;
  static e_WidgetElementOutput;
  static e_WidgetElementPsMap;
  static e_WidgetElementExcludeNS;
  static e_WidgetElementAssist;
  static e_WidgetElementPicture;
  static e_WidgetElementTraversal;
  static e_WidgetElementSilentPrint;
  static e_WidgetElementWebClient;
  static e_WidgetElementLayoutPseudoModel;
  static e_WidgetElementProducer;
  static e_WidgetElementCorner;
  static e_WidgetElementMsgId;
  static e_WidgetElementColor;
  static e_WidgetElementKeep;
  static e_WidgetElementQuery;
  static e_WidgetElementInsert;
  static e_WidgetElementImageEdit;
  static e_WidgetElementValidate;
  static e_WidgetElementDigestMethods;
  static e_WidgetElementNumberPatterns;
  static e_WidgetElementPageSet;
  static e_WidgetElementInteger;
  static e_WidgetElementSoapAddress;
  static e_WidgetElementEquate;
  static e_WidgetElementFormFieldFilling;
  static e_WidgetElementPageRange;
  static e_WidgetElementUpdate;
  static e_WidgetElementConnectString;
  static e_WidgetElementMode;
  static e_WidgetElementLayout;
  static e_WidgetElementSharpxml;
  static e_WidgetElementXsdConnection;
  static e_WidgetElementTraverse;
  static e_WidgetElementEncodings;
  static e_WidgetElementTemplate;
  static e_WidgetElementAcrobat;
  static e_WidgetElementValidationMessaging;
  static e_WidgetElementSigning;
  static e_WidgetElementDataWindow;
  static e_WidgetElementScript;
  static e_WidgetElementAddViewerPreferences;
  static e_WidgetElementAlwaysEmbed;
  static e_WidgetElementPasswordEdit;
  static e_WidgetElementNumericEdit;
  static e_WidgetElementEncryptionMethod;
  static e_WidgetElementChange;
  static e_WidgetElementPageArea;
  static e_WidgetElementSubmitUrl;
  static e_WidgetElementOids;
  static e_WidgetElementSignature;
  static e_WidgetElementADBE_JSConsole;
  static e_WidgetElementCaption;
  static e_WidgetElementRelevant;
  static e_WidgetElementFlipLabel;
  static e_WidgetElementExData;
  static e_WidgetElementDayNames;
  static e_WidgetElementSoapAction;
  static e_WidgetElementDefaultTypeface;
  static e_WidgetElementManifest;
  static e_WidgetElementOverflow;
  static e_WidgetElementLinear;
  static e_WidgetElementCurrencySymbol;
  static e_WidgetElementDelete;
  static e_WidgetElementDeltas;
  static e_WidgetElementDigestMethod;
  static e_WidgetElementInstanceManager;
  static e_WidgetElementEquateRange;
  static e_WidgetElementMedium;
  static e_WidgetElementTextEdit;
  static e_WidgetElementTemplateCache;
  static e_WidgetElementCompressObjectStream;
  static e_WidgetElementDataValue;
  static e_WidgetElementAccessibleContent;
  static e_WidgetElementNodeList;
  static e_WidgetElementIncludeXDPContent;
  static e_WidgetElementXmlConnection;
  static e_WidgetElementValidateApprovalSignatures;
  static e_WidgetElementSignData;
  static e_WidgetElementPackets;
  static e_WidgetElementDatePattern;
  static e_WidgetElementDuplexOption;
  static e_WidgetElementBase;
  static e_WidgetElementBind;
  static e_WidgetElementCompression;
  static e_WidgetElementUser;
  static e_WidgetElementRectangle;
  static e_WidgetElementEffectiveOutputPolicy;
  static e_WidgetElementADBE_JSDebugger;
  static e_WidgetElementAcrobat7;
  static e_WidgetElementInteractive;
  static e_WidgetElementLocale;
  static e_WidgetElementCurrentPage;
  static e_WidgetElementData;
  static e_WidgetElementDate;
  static e_WidgetElementDesc;
  static e_WidgetElementEncrypt;
  static e_WidgetElementDraw;
  static e_WidgetElementEncryption;
  static e_WidgetElementMeridiemNames;
  static e_WidgetElementMessaging;
  static e_WidgetElementSpeak;
  static e_WidgetElementDataGroup;
  static e_WidgetElementCommon;
  static e_WidgetElementSharptext;
  static e_WidgetElementPaginationOverride;
  static e_WidgetElementReasons;
  static e_WidgetElementSignatureProperties;
  static e_WidgetElementThreshold;
  static e_WidgetElementAppearanceFilter;
  static e_WidgetElementFill;
  static e_WidgetElementFont;
  static e_WidgetElementForm;
  static e_WidgetElementMediumInfo;
  static e_WidgetElementCertificate;
  static e_WidgetElementPassword;
  static e_WidgetElementRunScripts;
  static e_WidgetElementTrace;
  static e_WidgetElementFloat;
  static e_WidgetElementRenderPolicy;
  static e_WidgetElementLogPseudoModel;
  static e_WidgetElementDestination;
  static e_WidgetElementValue;
  static e_WidgetElementBookend;
  static e_WidgetElementExObject;
  static e_WidgetElementXMLData;
  static e_WidgetElementOpenAction;
  static e_WidgetElementNeverEmbed;
  static e_WidgetElementBindItems;
  static e_WidgetElementCalculate;
  static e_WidgetElementPrint;
  static e_WidgetElementExtras;
  static e_WidgetElementProto;
  static e_WidgetElementDSigData;
  static e_WidgetElementCreator;
  static e_WidgetElementConnect;
  static e_WidgetElementPermissions;
  static e_WidgetElementConnectionSet;
  static e_WidgetElementSubmit;
  static e_WidgetElementRange;
  static e_WidgetElementLinearized;
  static e_WidgetElementPacket;
  static e_WidgetElementRootElement;
  static e_WidgetElementPlaintextMetadata;
  static e_WidgetElementNumberSymbols;
  static e_WidgetElementPrintHighQuality;
  static e_WidgetElementDriver;
  static e_WidgetElementIncrementalLoad;
  static e_WidgetElementSubjectDN;
  static e_WidgetElementCompressLogicalStructure;
  static e_WidgetElementIncrementalMerge;
  static e_WidgetElementRadial;
  static e_WidgetElementVariables;
  static e_WidgetElementTimePatterns;
  static e_WidgetElementEffectiveInputPolicy;
  static e_WidgetElementNameAttr;
  static e_WidgetElementConformance;
  static e_WidgetElementTransform;
  static e_WidgetElementLockDocument;
  static e_WidgetElementBreakAfter;
  static e_WidgetElementLine;
  static e_WidgetElementList;
  static e_WidgetElementSource;
  static e_WidgetElementOccur;
  static e_WidgetElementPickTrayByPDFSize;
  static e_WidgetElementMonthNames;
  static e_WidgetElementSeverity;
  static e_WidgetElementGroupParent;
  static e_WidgetElementEncryptData;
  static e_WidgetElementDocumentAssembly;
  static e_WidgetElementNumberSymbol;
  static e_WidgetElementTagged;
  static e_WidgetElementItems;
 
  static e_WidgetAttributeTypeH;
  static e_WidgetAttributeTypeW;
  static e_WidgetAttributeTypeX;
  static e_WidgetAttributeTypeY;
  static e_WidgetAttributeTypeLineThrough;
  static e_WidgetAttributeTypeLineHAlign;
  static e_WidgetAttributeTypeTypeface;
  static e_WidgetAttributeTypeFontHorizontalScale;
  static e_WidgetAttributeTypeTextIndent;
  static e_WidgetAttributeTypeLeftInset;
  static e_WidgetAttributeTypeBottomInset;
  static e_WidgetAttributeTypeAllowRichText;
  static e_WidgetAttributeTypeTopInset;
  static e_WidgetAttributeTypeAccess;
  static e_WidgetAttributeTypeMarginRight;
  static e_WidgetAttributeTypeRotate;
  static e_WidgetAttributeTypeUnderline;
  static e_WidgetAttributeTypeBaselineShift;
  static e_WidgetAttributeTypeOverlinePeriod;
  static e_WidgetAttributeTypeFracDigits;
  static e_WidgetAttributeTypeMarginLeft;
  static e_WidgetAttributeTypeStroke;
  static e_WidgetAttributeTypePresence;
  static e_WidgetAttributeTypeMultiLine;
  static e_WidgetAttributeTypeSpaceBelow;
  static e_WidgetAttributeTypeNumberOfCells;
  static e_WidgetAttributeTypeLetterSpacing;
  static e_WidgetAttributeTypePasswordChar;
  static e_WidgetAttributeTypeVAlign;
  static e_WidgetAttributeTypeMaxH;
  static e_WidgetAttributeTypeMaxW;
  static e_WidgetAttributeTypeMinH;
  static e_WidgetAttributeTypeMinW;
  static e_WidgetAttributeTypeLayout;
  static e_WidgetAttributeTypeRightInset;
  static e_WidgetAttributeTypeLineThroughPeriod;
  static e_WidgetAttributeTypeShape;
  static e_WidgetAttributeTypeBorderWidth;
  static e_WidgetAttributeTypeLocale;
  static e_WidgetAttributeTypeWeight;
  static e_WidgetAttributeTypeUnderlinePeriod;
  static e_WidgetAttributeTypeOverline;
  static e_WidgetAttributeTypeLineHeight;
  static e_WidgetAttributeTypeValue;
  static e_WidgetAttributeTypeTextEncoding;
  static e_WidgetAttributeTypeLeadDigits;
  static e_WidgetAttributeTypeSpaceAbove;
  static e_WidgetAttributeTypePlacement;
  static e_WidgetAttributeTypeBorderColor;
  static e_WidgetAttributeTypeFillColor;
  static e_WidgetAttributeTypeFontColor;
  static e_WidgetAttributeTypeUnknown;
 
  constructor(r);
 
  constructor();
 
  constructor(event_type, page_index, element, attribute_type, old_value, new_value, widget_name);
 
  event_type;
 
  page_index;
 
  element;
 
  attribute_type;
 
  old_value;
 
  new_value;
 
  widget_name;
}
 
export class IDocProviderCallback {
  Release();
 
  InvalidateRect(page_index, rect, flag);
 
  DisplayCaret(page_index, is_visible, rect);
 
  GetPopupPos(page_index, min_popup, max_popup,
    rect_widget, inout_rect_popupconst);
 
  PopupMenu(page_index, rect_popup);
 
  GetCurrentPage(doc);
 
  SetCurrentPage(doc, current_page_index);
 
  SetChangeMark(doc);
 
  GetTitle(doc);
 
  SetFocus(xfa_widget, is_relayout);
 
  ExportData(doc, file_path);
 
  ImportData(doc, file_path);
 
  GotoURL(doc, url);
 
  Print(doc, start_page_index, end_page_index, options);
 
  GetHighlightColor(doc);
 
  SubmitData(doc, target, format, text_encoding,
    content);
 
  PageViewEvent(page_index, page_view_event_type);
 
  WidgetEvent(xfa_widget, widget_event_type);
 
  NotifyWidgetChangeInfo(doc, change_info);
}
 
 
export namespace AppProviderCallback {
  export const e_AppInfoVersion;
 
  export const e_AppInfoLanguage;
 
  export const e_AppInfoPlatform;
 
  export const e_AppInfoVariation;
 
  export const e_AppInfoName;
 
  export const e_AppInfoType;
 
  export const e_BeepTypeError;
 
  export const e_BeepTypeWarning;
 
  export const e_BeepTypeQuestion;
 
  export const e_BeepTypeStatus;
 
  export const e_BeepTypeDefault;
 
  export const e_StringIDValidateFailed;
 
  export const e_StringIDCalcOverride;
 
  export const e_StringIDModifyField;
 
  export const e_StringIDNotModifyField;
 
  export const e_StringIDAppName;
 
  export const e_StringIDImageFilter;
 
  export const e_StringIDUnknownCaught;
 
  export const e_StringIDUnableToSet;
 
  export const e_StringIDValueExcalmatory;
 
  export const e_StringIDInvalidEnumValue;
 
  export const e_StringIDUnsupportMethod;
 
  export const e_StringIDUnsupportProperty;
 
  export const e_StringIDInvalidPropertySetOperation;
 
  export const e_StringIDNotDefaultValue;
 
  export const e_StringIDUnableSetLanguage;
 
  export const e_StringIDUnableSetNumPages;
 
  export const e_StringIDUnableSetPlatformValue;
 
  export const e_StringIDUnableSetValidationsEnabledValue;
 
  export const e_StringIDUnableSetValidationsValue;
 
  export const e_StringIDUnableSetVersion;
 
  export const e_StringIDUnableSetReady;
 
  export const e_StringIDNumberOfOccur;
 
  export const e_StringIDUnableSetClassName;
 
  export const e_StringIDUnableSetLengthValue;
 
  export const e_StringIDUnsupportChar;
 
  export const e_StringIDBadSuffix;
 
  export const e_StringIDExpectedIdent;
 
  export const e_StringIDExpectedString;
 
  export const e_StringIDInvalidateChar;
 
  export const e_StringIDRedefinition;
 
  export const e_StringIDInvalidToken;
 
  export const e_StringIDInvalidExpression;
 
  export const e_StringIDUndefineIdentifier;
 
  export const e_StringIDInvalidateLeftValue;
 
  export const e_StringIDCompilerError;
 
  export const e_StringIDCannotModifyValue;
 
  export const e_StringIDParametersError;
 
  export const e_StringIDExpectedEndIf;
 
  export const e_StringIDUnexpectedExpression;
 
  export const e_StringIDConditionIsNull;
 
  export const e_StringIDIllegalBreak;
 
  export const e_StringIDIllegalContinue;
 
  export const e_StringIDExpectedOperator;
 
  export const e_StringIDDivideZero;
 
  export const e_StringIDCannotCovertToObject;
 
  export const e_StringIDNotFoundContainer;
 
  export const e_StringIDNotFoundProperty;
 
  export const e_StringIDNotFoundMethod;
 
  export const e_StringIDNotFoundConst;
 
  export const e_StringIDNotAssignObject;
 
  export const e_StringIDInvalidateInstruction;
 
  export const e_StringIDExpectedNumber;
 
  export const e_StringIDValidateOutOfArray;
 
  export const e_StringIDCannotAssign;
 
  export const e_StringIDNotFoundFunction;
 
  export const e_StringIDIsNotArray;
 
  export const e_StringIDOutOfArrayRange;
 
  export const e_StringIDNotSupportArrayCalculate;
 
  export const e_StringIDArgumentNotArray;
 
  export const e_StringIDArgumentExpectContainer;
 
  export const e_StringIDAccessProertyInNotObject;
 
  export const e_StringIDFunctionBuildIn;
 
  export const e_StringIDErrorMessage;
 
  export const e_StringIDIndexValueOutOfBounds;
 
  export const e_StringIDIncorrectNumberOfMethod;
 
  export const e_StringIDArgumentMismatch;
 
  export const e_StringIDInvalidEnumerate;
 
  export const e_StringIDInvalidAppend;
 
  export const e_StringIDSOMExpectedList;
 
  export const e_StringIDNotHaveProperty;
 
  export const e_StringIDInvalidNodeType;
 
  export const e_StringIDViolateBoundary;
 
  export const e_StringIDServerDeny;
 
  export const e_StringIDWeekDaySun;
 
  export const e_StringIDWeekDayMon;
 
  export const e_StringIDWeekDayTue;
 
  export const e_StringIDWeekDayWed;
 
  export const e_StringIDWeekDayThu;
 
  export const e_StringIDWeekDayFri;
 
  export const e_StringIDWeekDaySat;
 
  export const e_StringIDMonthJan;
 
  export const e_StringIDMonthFeb;
 
  export const e_StringIDMonthMarch;
 
  export const e_StringIDMonthApril;
 
  export const e_StringIDMonthMay;
 
  export const e_StringIDMonthJune;
 
  export const e_StringIDMonthJuly;
 
  export const e_StringIDMonthAug;
 
  export const e_StringIDMonthSep;
 
  export const e_StringIDMonthOct;
 
  export const e_StringIDMonthNov;
 
  export const e_StringIDMonthDec;
 
  export const e_StringIDToday;
 
  export const e_StringIDValidateLimit;
 
  export const e_StringIDValidateNullWarning;
 
  export const e_StringIDValidateNullError;
 
  export const e_StringIDValidateWarning;
 
  export const e_StringIDValidateError;
 
  export const e_StringIDValidateNumberError;
 
  export const e_StringIDScriptFailedError;
 
  export const e_StringIDScriptInvalidValue;
 
  export const e_StringIDSubmitValidateNullError;
 
  export const e_StringIDInvalidBarcodeValue;
 
  export const e_StringIDScriptArgumentMismatch;
 
 
  export const e_MsgBoxIconError;
 
  export const e_MsgBoxIconWarning;
 
  export const e_MsgBoxIconQuestion;
 
  export const e_MsgBoxIconStatus;
 
 
  export const e_MsgBtnTypeOK;
 
  export const e_MsgBtnTypeOKCancel;
 
  export const e_MsgBtnTypeYesNo;
 
  export const e_MsgBtnTypeYesNoCancel;
 
 
  export const e_MsgBtnIDOK;
 
  export const e_MsgBtnIDCancel;
 
  export const e_MsgBtnIDNo;
 
  export const e_MsgBtnIDYes;
 
}
 
export class IAppProviderCallback {
  Release();
 
  GetAppInfo(app_info);
 
  Beep(type);
 
  MsgBox(message, title, icon_type,
    button_type);
 
  Response(question, title, default_answer,
    is_mask);
 
  DownLoadUrl(url);
 
  PostRequestURL(url, data, content_type,
    encode, header);
 
  PutRequestURL(url, data, encode,);
 
  LoadString(string_id);
 
  ShowFileDialog(string_title, string_filter,
    is_openfile_dialog);
}
// End of /Users/ec2-user/gitlab-runner/builds/E-xKdhDoq/0/foxit/sdk/mobile/harmonyrdk/script/../foxit_rdk/src/main/cpp/types/libfoxit_rdk_native/addon/xfa/xfa.d.ts
// Start of /Users/ec2-user/gitlab-runner/builds/E-xKdhDoq/0/foxit/sdk/mobile/harmonyrdk/script/../foxit_rdk/src/main/cpp/types/libfoxit_rdk_native/addon/optimization/optimization.d.ts
 
export class Optimizer extends NativeObjectWrapper {
  static Optimize(doc, settings, pause);
 
  static StartSubsetEmbedFont(doc, pause);
 
  static OptimizeScannedPDF(doc, settings,
    image_compress_callback, pause);
 
  static ComputeAuditSpace(doc);
}
 
export class ImageSettings extends NativeObjectWrapper {
  static e_ImageCompressHigh;
  static e_ImageCompressjpeg;
  static e_ImageCompressjpeg2000;
  static e_ImageCompressRetain;
  static e_ImageCompressZip;
 
 
  static e_ImageCompressQualityMinimum;
  static e_ImageCompressQualityLow;
  static e_ImageCompressQualityMedium;
  static e_ImageCompressQualityHigh;
  static e_ImageCompressQualityMaximum;
  static e_ImageCompressQualityLossless;
 
  static e_StretchDefault;
  static e_StretchOff;
  static e_StretchInterpol;
  static e_StretchDownsample;
  static e_StretchBicubic;
  static e_StretchNoSmooth;
 
  constructor(r);
  constructor();
 
  IsEmpty();
 
  SetStretchMode(mode);
 
  SetImageDPI(dpi);
 
  SetImageDPILimit(dpi_limit);
 
  SetCompressionMode(mode);
 
  SetQuality(quality);
 
  SetBackgroundDownScale(down_scale);
 
  SetForegroundDownScale(down_scale);
 
  SetTextSensitivity(text_sensitivity);
 
  SetTileSize(size);
}
 
export class MonoImageSettings extends NativeObjectWrapper {
  static e_ImageCompressCCITT3;
  static e_ImageCompressCCITT4;
  static e_ImageCompressHigh;
  static e_ImageCompressjbig2;
  static e_ImageCompressRetain;
  static e_ImageCompressRunLength;
  static e_ImageCompressZip;
 
 
  static e_ImageCompressQualityLossless;
  static e_ImageCompressQualityLossy;
  static e_ImageCompressQualityMinimum;
  static e_ImageCompressQualityLow;
  static e_ImageCompressQualityMedium;
  static e_ImageCompressQualityHigh;
  static e_ImageCompressQualityMaximum;
 
  static e_StretchDefault;
  static e_StretchOff;
  static e_StretchInterpol;
  static e_StretchDownsample;
  static e_StretchBicubic;
  static e_StretchNoSmooth;
 
  constructor(r);
  constructor();
 
  IsEmpty();
 
  SetImageDPI(dpi);
 
  SetImageDPILimit(dpi_limit);
 
  SetCompressionMode(mode);
 
  SetStretchMode(mode);
 
  SetQuality(quality);
}
 
export class UnembeddedFontSettings extends NativeObjectWrapper {
 
  constructor(r);
  constructor();
 
  IsEmpty();
 
  SetSubsetAllEmFonts(is_subset_all_emb_fonts);
 
  SetUnembeddedFontNameArray(font_name_array);
}
 
export class OptimizerSettings extends NativeObjectWrapper {
  static e_OptimizerCompressImages;
  static e_OptimizerCleanUp;
  static e_OptimizerDiscardObjects;
  static e_OptimizerUnembeddedFonts;
  static e_OptimizerDiscardUserData;
  static e_OptimizerTransparency;
 
 
  static e_TransparencyModeLowResolution;
  static e_TransparencyModeMediumResolution;
  static e_TransparencyModeHighResolution;
 
 
  static e_CleanUpUseFlateForNonEncodedStream;
  static e_CleanUpUseFlateInsteadOfLZW;
  static e_CleanUpRemoveInvalidBookmarks;
  static e_CleanUpRemoveInvalidLinks;
  static e_CleanUpDiscardUnreferencedNamedDes;
  static e_CleanUpOptPageContent;
 
  static e_DiscardObjectsFormActions;
  static _DiscardObjectsFlattenFormFields;
  static e_DiscardObjectsJavaScriptActions;
  static e_DiscardObjectsEmbeddedPageThumbnails;
  static e_DiscardObjectsEmbeddedPrintSettings;
  static e_DiscardObjectsBookmarks;
  static e_DiscardObjectsAlternateImages;
  static e_DiscardObjectsDocumentTags;
  static e_DiscardObjectsEmbeddedSearchIndex;
  static e_DiscardObjectsDetectAndMergeImageFragment;
  static e_DiscardObjectsSmoothlinestocurves;
 
  static e_DiscardUserDataAllAnnotsFormsAndMultimedia;
  static e_DiscardUserDataExternalCrossReferences;
  static e_DiscardUserDataDocumentInfoAndMetaData;
  static e_DiscardUserDataFileAttchments;
  static e_DiscardUserDataPrivateDataOfOtherApp;
  static e_DiscardUserDataLayer;
  static e_DiscardUserAllData;
 
  constructor(r);
 
  constructor();
 
  IsEmpty();
 
  SetOptimizerOptions(optimize_options);
 
  SetColorGrayImageSettings(settings);
 
  SetMonoImageSettings(settings);
 
  SetUnembeddedFontSettings(settings);
 
  SetCleanUpOptions(clean_up_options);
 
  SetDiscardObjectsOptions(discard_objects_options);
 
  SetDiscardUserDataOptions(discard_userdata_options);
 
  SetTransparencyMode(transparency_mode) ;
}
 
export class OptimizeScannedPDFSettings extends NativeObjectWrapper {
  static e_ScannedImageCompressHigh;
  static e_ScannedImageCompressjpeg;
  static e_ScannedImageCompressjpeg2000LossLess;
  static e_ScannedImageCompressjpeg2000Lossy;
 
  static e_ScannedMonoImageCompressjbig2Lossy;
  static e_ScannedMonoImageCompressjbig2LossLess;
  static e_ScannedMonoImageCompressCCITT4;
  static e_ScannedMonoImageCompressHigh;
 
  constructor();
 
  constructor(other);
 
  IsEmpty();
 
  SetOptimizedPages(pages);
 
  SetColorGrayImageCompressionMode(mode);
 
  SetColorGrayImageCompressionQuality(quality);
 
  SetMonoImageCompressionMode(mode);
}
 
export class ImageCompressionCallback extends NativeObjectWrapper {
  Release();
 
  GetTemporaryFileStream(bitmap);
}
 
export class AuditSpaceSize extends NativeObjectWrapper {
  constructor();
 
  content_streams;
 
  images;
 
  fonts;
 
  bookmarks;
 
  x_object_forms;
 
  structure_infos;
 
  acroforms;
 
  link_annots;
 
  named_destnations;
 
  color_space;
 
  pattern_infos;
 
  piece_infos;
 
  comments_and_3d_contents;
 
  shading_pattern_infos;
 
  extend_graphics_states;
 
  cross_ref_tables;
 
  thumbs;
 
  embed_files;
 
  web_infos;
}
// End of /Users/ec2-user/gitlab-runner/builds/E-xKdhDoq/0/foxit/sdk/mobile/harmonyrdk/script/../foxit_rdk/src/main/cpp/types/libfoxit_rdk_native/addon/optimization/optimization.d.ts
// Start of /Users/ec2-user/gitlab-runner/builds/E-xKdhDoq/0/foxit/sdk/mobile/harmonyrdk/script/../foxit_rdk/src/main/cpp/types/libfoxit_rdk_native/addon/conversion/conversion.d.ts
 
export class HTML2PDFSettingData extends NativeObjectWrapper {
  static _PageModeSinglePage;
  static e_PageModeMultiplePage;
 
 
  static e_ScalingModeNone;
  static e_ScalingModeScale;
  static e_ScalingModeEnlarge;
 
 
  static e_EncodingFormatDefault;
  static e_EncodingFormatASCII;
  static e_EncodingFormatLatin2;
  static e_EncodingFormatLatin3;
  static e_EncodingFormatLatin4;
  static e_EncodingFormatLatin5;
  static e_EncodingFormatLatin6;
  static e_EncodingFormatISO_8859_5;
  static e_EncodingFormatArabic;
  static e_EncodingFormatGreek;
  static e_EncodingFormatHebrew;
  static e_EncodingFormatEUC_JP;
  static e_EncodingFormatSJS;
  static e_EncodingFormatJIS;
  static e_EncodingFormatBIG5;
  static e_EncodingFormatGB;
  static e_EncodingFormatEUC_CN;
  static e_EncodingFormatKSC;
  static e_EncodingFormatUnicode;
  static e_EncodingFormatEUC;
  static e_EncodingFormatCNS;
  static e_EncodingFormatBIG5_CP950;
  static e_EncodingFormatASCII_7_bit;
  static e_EncodingFormatKOI8R;
  static e_EncodingFormatCP852;
  static e_EncodingFormatCP866;
  static e_EncodingFormatCP874;
  static e_EncodingFormatCP932;
  static e_EncodingFormatCP1250;
  static e_EncodingFormatCP1251;
  static e_EncodingFormatCP1252;
  static e_EncodingFormatCP1253;
  static e_EncodingFormatCP1254;
  static e_EncodingFormatCP1255;
  static e_EncodingFormatCP1256;
  static e_EncodingFormatCP1257;
  static e_EncodingFormatKOI8U;
  static e_EncodingFormatISO_8859_15;
  static e_EncodingFormatISO_8859_11;
  static e_EncodingFormatISO_8859_8_I;
  static e_EncodingFormatVISUAL;
  static e_EncodingFormatCSN_369103;
  static e_EncodingFormatISO_8859_13;
  static e_EncodingFormatISO_2022_KR;
  static e_EncodingFormatGBK;
  static e_EncodingFormatGB18030;
  static e_EncodingFormatBIG5_HKSCS;
  static e_EncodingFormatISO_2022_CN;
  static e_EncodingFormatTSCII;
  static e_EncodingFormatTAM;
  static e_EncodingFormatTAB;
  static e_EncodingFormatJAGRAN;
  static e_EncodingFormatMACINTOSH;
  static e_EncodingFormatUTF7;
  static e_EncodingFormatBHASKAR;
  static e_EncodingFormatHTCHANAKYA;
  static e_EncodingFormatUTF_16BE;
  static e_EncodingFormatUTF_16LE;
  static e_EncodingFormatUTF_32BE;
  static e_EncodingFormatUTF_32LE;
  static e_EncodingFormatX_BINARYENC;
  static e_EncodingFormatHZ_GB_2312;
  static e_EncodingFormatX_UTF8UTF8;
  static e_EncodingFormatX_TAM_ELANGO;
  static e_EncodingFormatX_TAM_LTTMBARANI;
  static e_EncodingFormatX_TAM_SHREE;
  static e_EncodingFormatX_TAM_TBOOMIS;
  static e_EncodingFormatX_TAM_TMNEWS;
  static e_EncodingFormatX_TAM_WEBTAMIL;
  static e_EncodingFormatX_KDDI_Shift_JIS;
  static e_EncodingFormatX_DoCoMo_Shift_JIS;
  static e_EncodingFormatX_SoftBank_Shift_JIS;
  static e_EncodingFormatX_KDDI_ISO_2022_JP;
  static e_EncodingFormatX_SoftBank_ISO_2022_JP;
 
  static e_MediaStyleScreen;
  static e_MediaStylePrint;
 
  constructor(r);
  constructor()
 
  
  constructor(page_width, page_height, is_to_page_scale, page_margin,
    is_convert_link, rotate_degrees, is_generate_tag, page_mode,
    to_generate_bookmarks, scaling_mode,
    encoding_format, to_render_images, to_remove_underline_for_link,
    to_set_headerfooter, headerfooter_title,
    headerfooter_url, bookmark_root_name, to_resize_objects, to_print_background,
    to_optimize_tag_tree,
    media_style, to_load_active_content, to_disable_sandbox, to_use_blacklist,
    to_hide_header, to_hide_footer, to_deny_local_file_access);
 
 
  Set(page_width, page_height, is_to_page_scale, page_margin,
    is_convert_link, rotate_degrees, is_generate_tag, page_mode,
    to_generate_bookmarks, scaling_mode,
    encoding_format, to_render_images, to_remove_underline_for_link,
    to_set_headerfooter, headerfooter_title,
    headerfooter_url, bookmark_root_name, to_resize_objects, to_print_background,
    to_optimize_tag_tree,
    media_style, to_load_active_content, to_disable_sandbox,
    to_use_blacklist, to_hide_header, to_hide_footer, to_deny_local_file_access);
 
  page_width;
 
  page_height;
 
  is_to_page_scale;
 
  page_margin;
 
  rotate_degrees;
 
  is_convert_link;
 
  is_generate_tag;
 
  page_mode
 
  to_generate_bookmarks;
 
  scaling_mode;
 
  encoding_format;
 
  to_render_images;
 
  to_remove_underline_for_link;
 
  to_set_headerfooter;
 
  headerfooter_title;
 
  headerfooter_url;
 
  bookmark_root_name;
 
  to_resize_objects;
 
  to_print_background;
 
  to_optimize_tag_tree;
 
  media_style;
 
  to_load_active_content;
 
  to_disable_sandbox;
 
  to_use_blacklist;
 
  to_hide_header;
 
  to_hide_footer;
 
  to_deny_local_file_access;
}
 
export class TXT2PDFSettingData extends NativeObjectWrapper {
 
  constructor(r);
  constructor();
 
  constructor(page_width, page_height, page_margin, font, text_size,
    text_color, linespace, is_break_page);
 
  Set(page_width, page_height, page_margin, font, text_size,
    text_color, linespace, is_break_page);
 
  page_width;
 
  page_height;
 
  page_margin;
 
  font;
 
  text_size;
 
  text_color;
 
  linespace;
 
  is_break_page;
}
 
export class DWG2PDFSettingData extends NativeObjectWrapper {
  static e_FlagEmbededTTF;
  static e_FlagTTFTextAsGeometry;
  static e_FlagSHXTextAsGeometry;
  static e_FlagSimpleGeomOptimization;
  static e_FlagEnableLayers;
  static e_FlagIncludeOffLayers;
  static e_FlagEmbededOptimizedTTF;
  static e_FlagUseHLR;
  static e_FlagFlateCompression;
  static e_FlagASCIIHexEncoding;
  static e_FlagExportHyperlinks;
  static e_FlagZoomToExtentsMode;
  static e_FlagLinearized;
  static e_FlagMeasuring
 
  static e_DWG2PDFExportHatchesTypeBitmap;
  static e_DWG2PDFExportHatchesTypeDrawing;
  static e_DWG2PDFExportHatchesTypePdfPaths;
  static e_DWG2PDFExportHatchesTypePolygons;
 
  static e_DWG2PDFSearchableTextTypeNoSearch;
  static e_DWG2PDFSearchableTextTypeSHX;
  static e_DWG2PDFSearchableTextTypeTTF;
 
  constructor(r);
 
  constructor();
 
  export_flags;
 
  export_hatches_type;
 
  other_export_hatches_type;
 
  gradient_export_hatches_type;
 
  searchable_text_type;
 
  is_active_layout;
 
  output_title;
 
  output_author;
 
  output_subject;
 
  output_keywords;
 
  output_creator;
 
  output_producer;
 
  paper_width;
 
  paper_height;
}
 
 
export class Word2PDFSettingData extends NativeObjectWrapper {
  static e_ConvertOptimizeOptionForPrint;
  static e_ConvertOptimizeOptionForOnScreen;
 
  static e_ConvertContentOptionOnlyContent;
  static e_ConvertContentOptionWithMarkup;
 
  static e_ConvertBookmarkOptionNone;
  static e_ConvertBookmarkOptionUseHeadings;
  static e_ConvertBookmarkOptionUseWordBookmark;
 
  constructor(r);
 
  constructor();
 
  constructor(include_doc_props, optimize_option,
    content_option, bookmark_option,
    convert_to_pdfa, disable_vba_code);
 
 
  Set(include_doc_props, optimize_option,
    content_option, bookmark_option,
    convert_to_pdfa, disable_vba_code);
 
  include_doc_props;
 
  optimize_option;
 
  content_option;
 
  bookmark_option;
 
  convert_to_pdfa;
 
  disable_vba_code;
}
 
export class Excel2PDFSettingData extends NativeObjectWrapper {
  e_ConvertQualityStandard;
  e_ConvertQualityMinimum;
 
 
  e_ScaleTypeNone;
  e_ScaleTypeFitAllColumns;
  e_ScaleTypeFitAllRows;
  e_ScaleTypeFitSheet;
 
  constructor(r);
  constructor();
 
  constructor(include_doc_props, quality, ignore_print_area,
    scale_type, convert_to_pdfa, disable_vba_code);
 
 
  Set(include_doc_props, quality, ignore_print_area,
    scale_type, convert_to_pdfa, disable_vba_code);
 
 
  include_doc_props;
 
  quality;
 
  ignore_print_area;
 
  scale_type;
 
  convert_to_pdfa;
 
  disable_vba_code;
}
 
export class PowerPoint2PDFSettingData extends NativeObjectWrapper {
  e_ConvertIntentPrint;
  e_ConvertIntentScreen;
 
  e_HandoutOrderHorizontalFirst;
  e_HandoutOrderVerticalFirst;
 
  e_OutputSlides;
  e_OutputNotesPages;
  e_OutputOutline;
  e_OutputOneSlideHandouts;
  e_OutputTwoSlideHandouts;
  e_OutputThreeSlideHandouts;
  e_OutputFourSlideHandouts;
  e_OutputSixSlideHandouts;
  e_OutputNineSlideHandouts;
 
  constructor(r);
  constructor();
 
  constructor(intent, frame_output_slides, output_type, handout_order,
    output_hidden_slides, include_doc_props, disable_vba_code);
 
  Set(intent, frame_output_slides, output_type, handout_order,
    output_hidden_slides, include_doc_props, disable_vba_code);
 
 
  intent;
 
  frame_output_slides;
 
  output_type;
 
  handout_order;
 
  output_hidden_slides;
 
  include_doc_props;
 
  disable_vba_code;
}
 
 
export class HTML2PDFRelatedResource extends NativeObjectWrapper {
 
  constructor(r);
  constructor();
 
  constructor(related_resource_file, resource_file_relative_path);
 
 
  related_resource_file;
 
  resource_file_relative_path;
}
 
 
export class HTML2PDFRelatedResourceArray extends NativeObjectWrapper {
 
  constructor(r);
  constructor();
 
  GetSize();
 
  GetAt(index);
 
  Add(element);
 
  RemoveAt(index);
 
  InsertAt(index, element);
 
  RemoveAll();
}
 
export class OFDConvertParam extends NativeObjectWrapper {
 
  constructor(r);
  constructor();
 
  constructor(is_embed_font);
 
  Set(is_embed_font);
 
 
  is_embed_font;
}
 
export class Convert extends NativeObjectWrapper {
  static e_Office2PdfEngineMicrosoft;
  static e_Office2PdfEngineWps;
 
  static FromHTML(src_html, engine_path, cookies_path, setting_data,
    saved_pdf_path, timeout);
 
  static FromHTML(src_html, engine_path, cookies_reader,
    setting_data, saved_pdf_path, timeout);
 
  static FromHTML(src_html, engine_path, cookies_reader,
    setting_data, saved_pdf_filestream, timeout);
 
  static FromHTML(src_html, html2pdf_related_resource_array,
    engine_path, cookies_reader, setting_data,
    saved_pdf_filestream, timeout);
 
  static FromTXT(src_txt, saved_pdf_path, setting_data);
 
  static FromImage(src_img, saved_pdf_path);
 
  static FromImage(file_reader, saved_pdf_filestream);
 
  static FromDWG(engine_pat, src_dwg_path, saved_pdf_path,
    settings);
 
 
  static FromWord(src_word_file_path, src_file_password, saved_pdf_path,
    setting_data);
 
  static FromExcel(src_excel_file_path, src_file_password, saved_pdf_path,
    setting_data);
 
  static FromPowerPoint(src_ppt_file_path, src_file_password, saved_pdf_path,
    setting_data);
 
  static FromWord(src_word_file_path, src_file_password, saved_pdf_path, engine_path,
    setting_data);
 
  static FromExcel(src_excel_file_path, src_file_password, saved_pdf_path,
    engine_path, setting_data);
 
  static FromPowerPoint(src_ppt_file_path, src_file_password, saved_pdf_path,
    engine_path, setting_data);
 
 
  static ToXML(src_pdf_path, src_file_password, saved_xml_path,
    saved_image_folder_path, is_force_to_tagged_pdf);
 
 
  static FromOFD(src_ofd_path, password, saved_pdf_file_path,
    OFDConvertParam);
 
  static ToOFD(src_pdf_path, password, saved_ofd_file_path,
    convert_param);
}
// End of /Users/ec2-user/gitlab-runner/builds/E-xKdhDoq/0/foxit/sdk/mobile/harmonyrdk/script/../foxit_rdk/src/main/cpp/types/libfoxit_rdk_native/addon/conversion/conversion.d.ts
// Start of /Users/ec2-user/gitlab-runner/builds/E-xKdhDoq/0/foxit/sdk/mobile/harmonyrdk/script/../foxit_rdk/src/main/cpp/types/libfoxit_rdk_native/addon/comparison/comparison.d.ts
 
export class CompareResultInfo extends NativeObjectWrapper {
  static e_CompareResultTypeNone;
  static e_CompareResultTypeDeleteText;
  static e_CompareResultTypeInsertText;
  static e_CompareResultTypeReplaceText;
  static e_CompareResultTypeDeleteImage;
  static e_CompareResultTypeInsertImage;
  static e_CompareResultTypeReplaceImage;
  static e_CompareResultTypeDeletePath;
  static e_CompareResultTypeInsertPath;
  static e_CompareResultTypeReplacePath;
  static e_CompareResultTypeDeleteShading;
  static e_CompareResultTypeInsertShading;
  static e_CompareResultTypeReplaceShading;
  static e_CompareResultTypeDeleteAnnot;
  static e_CompareResultTypeInsertAnnot;
  static e_CompareResultTypeReplaceAnnot;
  static e_CompareResultTypeTextAttriChange;
 
  constructor(r);
  constructor(type, rect_array, diff_contents);
 
  constructor()
 
  
  type;
 
  rect_array;
 
  diff_contents;
}
 
export class CompareResultInfoArray extends NativeObjectWrapper {
 
  constructor(r);
  constructor();
 
  GetSize();
 
  GetAt(index);
 
  Add(element);
 
  RemoveAt(index);
 
  InsertAt(index, element);
 
  RemoveAll();
}
 
 
export class CompareResults extends NativeObjectWrapper {
 
  constructor(r);
 
  constructor(base_doc_results, compared_doc_results);
 
  constructor();
 
 
  Clear();
 
  base_doc_results;
 
  compared_doc_results;
}
 
export class Comparison extends NativeObjectWrapper {
  static e_CompareTypeAll;
  static e_CompareTypeText;
  static e_CompareTypeAnnotation;
 
  constructor(r);
 
  constructor(base_doc, compared_doc);
 
  IsEmpty();
 
  DoCompare(base_page_index, compared_page_index, compare_flags);
 
  GenerateComparedDoc(compare_flags);
 
  GenerateComparedDoc(compare_flags, is_show_all_layers);
}
// End of /Users/ec2-user/gitlab-runner/builds/E-xKdhDoq/0/foxit/sdk/mobile/harmonyrdk/script/../foxit_rdk/src/main/cpp/types/libfoxit_rdk_native/addon/comparison/comparison.d.ts
// Start of /Users/ec2-user/gitlab-runner/builds/E-xKdhDoq/0/foxit/sdk/mobile/harmonyrdk/script/../foxit_rdk/src/main/cpp/types/libfoxit_rdk_native/custom/urlFileRead.d.ets
 
 
  export class UrlHeader extends NativeObjectWrapper{
    constructor();
    url;
 
    contentLength;
 
    eTag;
  }
 
  export class CacheOption {
    downloadAll;
    cacheFile
  }
 
  export class UrlFileRead implements IReaderCallback{
    constructor(urlHeader, cacheDir, cacheOption,
      requestOptions<string, string>, isReadFromCache);
 
    Release();
 
    GetSize();
 
    ReadBlock(offset, size);
 
    ReadBlock(buffer, offset, size);
  }
// End of /Users/ec2-user/gitlab-runner/builds/E-xKdhDoq/0/foxit/sdk/mobile/harmonyrdk/script/../foxit_rdk/src/main/cpp/types/libfoxit_rdk_native/custom/urlFileRead.d.ets
// Start of /Users/ec2-user/gitlab-runner/builds/E-xKdhDoq/0/foxit/sdk/mobile/harmonyrdk/script/../foxit_rdk/src/main/cpp/types/libfoxit_rdk_native/custom/util/util.d.ets
 
export class VoidObject {
}
 
export class CERT_INFO {
  certSerialNum;
  certPublisher;
  certStartDate;
  certEndDate;
  certEmailInfo;
  certOrganization;
  certOrganizationUnit;
  certUsageCode;
  cerInfoDic<string, string>;
}
 
export class DIGITALSIGNATURE_PARAM {
  certFile;
  certPwd;
  subfilter;
  signFilePath;
  imagePath;
  rect; // Assuming RectF is another interface you'll define
  sigName;
}
 
// For the PDFCertUtil class, you can use a TypeScript class or namespace
export class PDFCertUtil {
  static getCertInfo(path, pwd, info);
 
  static getCertFromSignatureContent(signature);[];
 
  static getTrustCertificateInformation(certData, info);
 
  static isCertTrusted(cert, needBeTrustedCertData); ;
}
// End of /Users/ec2-user/gitlab-runner/builds/E-xKdhDoq/0/foxit/sdk/mobile/harmonyrdk/script/../foxit_rdk/src/main/cpp/types/libfoxit_rdk_native/custom/util/util.d.ets
// Start of /Users/ec2-user/gitlab-runner/builds/E-xKdhDoq/0/foxit/sdk/mobile/harmonyrdk/script/../foxit_rdk/src/main/cpp/types/libfoxit_rdk_native/custom/task/task.d.ts
 
  export class ViewStatus extends NativeObjectWrapper {
    isContinuous;
    pageLayoutMode;
  }
  export class Task extends NativeObjectWrapper {
    constructor();
 
    prepare();
 
    canCancel();
 
    cancel();
 
    isCanceled();
 
    isModify();
 
    setStatus(status);
 
    getStatus();
 
    exeSuccess();
 
    setPriority(priority);
 
    getPriority();
 
    finish();
 
    setErrorCode(error);
 
    errorCode();
 
    extErrorCode();
 
    notify(result);
  }
 
  export declare class PageSizeTaskCallBack {
    constructor();
 
    result(task);
  }
 
 
  export class PageSizeTaskSettingData extends NativeObjectWrapper {
    constructor();
 
    pdfDoc;
    pageIndex;
    pageLayout;
    psWidth;
    psHeight;
    isContinuous;
    isDynamicXFA;
    xfaDoc;
    isPageViewVertical;
    reflowScale;
    viewWidth;
    viewHeight;
    reflowMode;
  }
 
  export class PageSizeTask extends Task {
    constructor(settingData, cb);
 
    getSettingData();
 
    getpdfPageSize();
 
    getdisplayPageSize();
  }
 
  export declare class CalculateMaxSizeCallback {
    constructor();
 
    execute(task);
  }
 
  export class CalculateMaxSizeTask extends Task {
    constructor(startIndex, endIndex, cb);
 
    getStartIndex();
 
    getEndIndex();
  }
 
  export declare class ClearCacheTaskCallBack {
    constructor();
 
    execute(task);
  }
 
  export class ClearCacheTask extends Task {
    constructor(cb);
  }
 
  export declare class CloseDocumentTaskCallback {
    constructor();
 
    result(task);
  }
 
  export class CloseDocumentTask extends Task {
    constructor(doc, cb);
 
    getPdfDoc();
  }
 
  export declare class CropPageSizeTaskCallback {
    constructor();
 
    execute(task);
 
    result(task);
  }
 
  export class CropPageSizeTask extends Task {
    constructor(pageIndex, cropRectF, cb);
 
    getPageIndex();
 
    getCropRectF();
  }
 
  export class DrawPageTaskSettingData extends NativeObjectWrapper {
    constructor();
 
    pdfDoc;
    xfaDoc;
    pageIndex;
    pageLayout;
    isContinuous;
    psWidth;
    psHeight;
    bmpArea;
    viewSize;
    cropMode;
    drawFor;
    rotate;
    nightMode;
    isDynamicXFA;
    isPageViewVertical;
    colorMode;
    bmpWidth;
    bmpHeight;
    backColor;
    textColor;
    reflowScale;
    viewWidth;
    viewHeight;
    reflowMode;
    reflowBackgroundColor;
    viewStatus;
  }
 
  export declare class DrawPageTaskCallBack {
    constructor();
 
    execute(task);
 
    result(task);
  }
 
  export class DrawPageTask extends Task {
    constructor(settingData, cb);
 
    getSettingData();
 
    getPDFPage();
 
    getReflowPage();
 
    getZoomScale();
 
    getRender();
 
    setBitmapBuffer(buffer);
 
    setPageReady(isPageReady);
 
    isPageReady();
 
    getStep();
 
    setProgress(isProgress);
 
    isProgress();
 
    setMatrix(matrix);
  }
 
  export declare class CalcPageContentTaskCallBack {
    constructor();
 
    result(task);
  }
 
  export class CalcPageContentTask extends Task {
    constructor(doc, pageIndex, cropMode, cb);
 
    getPageIndex();
 
    getRectF();
 
    getCropMode;
  }
 
  export class OpenDocumentSettingData extends NativeObjectWrapper {
    constructor();
 
    path;
    readerCallback;
    buffer;
    openType;
    password;
  }
 
  export declare class OpenDocumentTaskCallBack {
    constructor();
 
    execute(task);
 
    result(task);
  }
 
  export class OpenDocumentTask extends Task {
    constructor(settingData, openType, cb);
 
    getDocument();
 
    getXFADoc();
 
    isDynamicXFA();
  }
 
  export declare class SaveDocTaskCallBack {
    constructor();
 
    result(task);
  }
 
  export class SaveDocTask extends Task {
    constructor(doc, filePath, writer, flag, save_type,
      cb);
 
    getPdfDoc();
  }
 
 
  export class TaskServer extends NativeObjectWrapper {
    constructor();
 
    enableAddTask();
 
    disableAddTask();
 
    getCurTask();
 
    addTask(task);
 
    cancelTask(task, addToQueue);
 
    cancelAllTasks(force);
 
    handleTaskResult(task, isSync, addToQueue);
 
    setMachineStatus(status);
  }
 
 
  export class SearchResult extends NativeObjectWrapper {
    pageIndex;
 
    sentence;
 
    matchStartIndex;
 
    matchEndIndex;
 
    // matchRects;
 
    matchRect;
 
    GetMatchRects();
 
    Release();
  }
 
 
  export class SearchResultArray extends NativeObjectWrapper {
    constructor();
 
    GetSize();
 
 
    GetUpperBound();
 
    SetSize(nNewSize, nGrowBy);
 
    RemoveAll();
 
    GetAt(nIndex);
 
    SetAt(nIndex, newElement);
 
    SetAtGrow(nIndex, newElement);
 
    Add(ewElement);
 
    InsertAt(nIndex, newElement, nCount);
 
    RemoveAt(nIndex, nCount);
 
    InsertAt(nStartIndex, pNewArray);
 
    Find(data, iStart);
  }
 
 
  export class SearchPageInfo extends NativeObjectWrapper {
    taskId;
 
    errCode;
 
    pageIndex;
 
    searchFlags;
 
    keyWords;
 
    pdfDoc;
 
    searchResults;
 
    Release();
  }
 
 
  export declare class SearchPageTaskCallBack {
    constructor();
 
    result(task);
  }
 
 
  export class SearchPageTask extends Task {
    constructor(searchInfo, cb);
 
    getSearchPageInfo();
  }
 
  export const enum EditFormType {
 
    RESET_FORM,
    IMPORT_FORM,
    EXPORT_FORM
  }
 
 
  export declare class EditFormTaskCallBack {
    constructor();
 
    result(task);
  }
 
 
  export class EditFormTask extends Task {
    constructor(form, editType, filePath, cb);
  }
 
 
  export const enum EditCommentsType {
 
    IMPORT_COMMENTS,
    EXPORT_COMMENTS,
    EXPORT_HIGHLIGHT_TEXT
  }
 
 
  export declare class EditCommentsTaskCallBack {
    constructor();
 
    result(task);
  }
 
 
  export class EditCommentsTask extends Task {
    constructor(doc, editType, filePath, cb);
  }
 
export class RenderPageModel extends NativeObjectWrapper {
  constructor();
 
  pdfDoc;
 
  xfaDoc;
 
  pageIndex;
 
  rotate;
 
  colorMode;
 
  bmpWidth;
 
  bmpHeight;
 
  backColor;
 
  textColor;
}
 
export declare class RenderPageTaskCallBack {
  constructor();
 
  result(task);
}
 
export class RenderPageTask extends Task {
  constructor(renderInfo, cb);
 
  setBitmapBuffer(buffer);
}
 
export class PathInfo extends NativeObjectWrapper {
 
  constructor(path);
 
  getPoints(pointCount);<Array<number>>;
}
 
 
export class GetPagesInputParams extends NativeObjectWrapper {
  constructor();
 
  pdfDoc;
 
  startIndex;
 
  endIndex;
}
 
export declare class GetPagesInfoCallBack {
  constructor();
 
  result(task);
}
 
export class GetPagesInfoTask extends Task {
  constructor(params, cb);
 
  getResult();
}
 
// End of /Users/ec2-user/gitlab-runner/builds/E-xKdhDoq/0/foxit/sdk/mobile/harmonyrdk/script/../foxit_rdk/src/main/cpp/types/libfoxit_rdk_native/custom/task/task.d.ts