index.js

//  Copyright © 2018-2026 PSPDFKit GmbH d/b/a Nutrient. All rights reserved.
//
//  THIS SOURCE CODE AND ANY ACCOMPANYING DOCUMENTATION ARE PROTECTED BY INTERNATIONAL COPYRIGHT LAW
//  AND MAY NOT BE RESOLD OR REDISTRIBUTED. USAGE IS BOUND TO THE PSPDFKIT LICENSE AGREEMENT.
//  UNAUTHORIZED REPRODUCTION OR DISTRIBUTION IS SUBJECT TO CIVIL AND CRIMINAL PENALTIES.
//  This notice may not be removed from this file.
//

import PropTypes from 'prop-types';
import * as React from 'react';
import {
  findNodeHandle,
  NativeModules,
  Platform,
  requireNativeComponent,
  UIManager,
} from 'react-native';

/**
 * NutrientView is a React Native component used to view PDF documents on iOS and Android.
 * @augments {React.Component<Props, *>}
 * @hideconstructor
 * @example
 * <NutrientView
 *      document={DOCUMENT_PATH}
 *      configuration={{
 *        showThumbnailBar: PDFConfiguration.ShowThumbnailBar.SCROLLABLE,
 *        pageTransition: PDFConfiguration.PageTransition.SCROLL_CONTINUOUS,
 *        scrollDirection: PDFConfiguration.ScrollDirection.VERTICAL,
 *      }}
 *      ref={this.pdfRef}
 *      fragmentTag="PDF1"
 *      style={{ flex: 1 }}
 *    />
 */
class NutrientView extends React.Component {
  // Cache architecture detection and Fabric component to avoid work on every render
  static _isNewArchitecture = null;
  static _FabricComponent = null;

  static _getArchitectureInfo() {
    if (this._isNewArchitecture === null) {
      const {
        isNewArchitectureEnabled,
      } = require('./lib/ArchitectureDetector');
      this._isNewArchitecture = isNewArchitectureEnabled();

      if (this._isNewArchitecture) {
        try {
          // Require from src/ so Metro can process codegen for NutrientViewNativeComponent
          this._FabricComponent = require('./src/NutrientViewFabric').default;
        } catch (error) {
          console.error('[Nutrient] Failed to load Fabric component:', error);
          this._isNewArchitecture = false; // Fallback to Paper
          this._FabricComponent = null;
        }
      }
    }

    return {
      isNewArchitecture: this._isNewArchitecture,
      FabricComponent: this._FabricComponent,
    };
  }
  /**
   * @ignore
   */
  refs;
  /**
   * @ignore
   */
  _nextRequestId = 1;
  /**
   * @ignore
   */
  _requestMap = new Map();
  /**
   * @ignore
   */
  _pdfDocument = null;
  /**
   * @ignore
   */
  _notificationCenter = null;
  /**
   * @ignore
   */
  _componentRef = React.createRef(this);
  // Fabric ref used only in New Architecture to forward imperative methods
  _fabricRef = React.createRef();

  render() {
    // Architecture detection - use cached result to decide Fabric vs Paper
    const { isNewArchitecture, FabricComponent } =
      NutrientView._getArchitectureInfo();
    if (isNewArchitecture && FabricComponent) {
      return React.createElement(FabricComponent, {
        ...this.props,
        ref: this._fabricRef,
      });
    }

    if (Platform.OS === 'ios' || Platform.OS === 'android') {
      const onCloseButtonPressedHandler = this.props.onCloseButtonPressed
        ? event => {
            this.props.onCloseButtonPressed(event.nativeEvent);
          }
        : null;

      if (Platform.OS === 'android') {
        // Android: Only group document and configuration for proper ordering
        const {
          document,
          configuration,
          // Explicitly exclude document and configuration from otherProps
          ...otherProps
        } = this.props;

        // Only create combined prop for document and configuration
        const documentAndConfiguration = {
          document: document !== undefined ? document : null,
          configuration: configuration !== undefined ? configuration : null,
        };

        const hasShouldExecute = !!this.props.onShouldExecuteAction;
        const hasSignaturePadHandler = !!this.props.onShouldShowSignaturePad;
        const disableDefaultAction =
          this.props.disableDefaultActionForTappedAnnotations === true;

        return (
          <RCTPSPDFKitView
            ref={this._componentRef}
            documentAndConfiguration={documentAndConfiguration} // Android only
            fragmentTag="NutrientView.FragmentTag"
            {...otherProps}
            disableDefaultActionForTappedAnnotations={disableDefaultAction}
            onCloseButtonPressed={onCloseButtonPressedHandler}
            onStateChanged={this._onStateChanged}
            onDocumentSaved={this._onDocumentSaved}
            onDocumentLoaded={this._onDocumentLoaded}
            onDocumentSaveFailed={this._onDocumentSaveFailed}
            onDocumentLoadFailed={this._onDocumentLoadFailed}
            onAnnotationTapped={this._onAnnotationTapped}
            onAnnotationsChanged={this._onAnnotationsChanged}
            onNavigationButtonClicked={this._onNavigationButtonClicked}
            onDataReturned={this._onDataReturned}
            onCustomToolbarButtonTapped={this._onCustomToolbarButtonTapped}
            onCustomAnnotationContextualMenuItemTapped={
              this._onCustomAnnotationContextualMenuItemTapped
            }
            onCustomTextSelectionContextualMenuItemTapped={
              this._onCustomTextSelectionContextualMenuItemTapped
            }
            onReady={this._onReady}
            onShouldExecuteAction={
              hasShouldExecute ? this._onShouldExecuteAction : undefined
            }
            hasShouldExecuteAction={hasShouldExecute}
            onShouldShowSignaturePad={
              hasSignaturePadHandler
                ? this._onShouldShowSignaturePad
                : undefined
            }
            hasShouldShowSignaturePad={hasSignaturePadHandler}
          />
        );
      } else {
        // iOS: Use original approach with individual props
        const hasShouldExecute = !!this.props.onShouldExecuteAction;
        const hasSignaturePadHandler = !!this.props.onShouldShowSignaturePad;
        const disableDefaultAction =
          this.props.disableDefaultActionForTappedAnnotations === true;

        return (
          <RCTPSPDFKitView
            ref={this._componentRef}
            fragmentTag="NutrientView.FragmentTag"
            {...this.props}
            disableDefaultActionForTappedAnnotations={disableDefaultAction}
            onCloseButtonPressed={onCloseButtonPressedHandler}
            onStateChanged={this._onStateChanged}
            onDocumentSaved={this._onDocumentSaved}
            onDocumentLoaded={this._onDocumentLoaded}
            onDocumentSaveFailed={this._onDocumentSaveFailed}
            onDocumentLoadFailed={this._onDocumentLoadFailed}
            onAnnotationTapped={this._onAnnotationTapped}
            onAnnotationsChanged={this._onAnnotationsChanged}
            onNavigationButtonClicked={this._onNavigationButtonClicked}
            onDataReturned={this._onDataReturned}
            onCustomToolbarButtonTapped={this._onCustomToolbarButtonTapped}
            onCustomAnnotationContextualMenuItemTapped={
              this._onCustomAnnotationContextualMenuItemTapped
            }
            onReady={this._onReady}
            onShouldExecuteAction={
              hasShouldExecute ? this._onShouldExecuteAction : undefined
            }
            hasShouldExecuteAction={hasShouldExecute}
            onShouldShowSignaturePad={
              hasSignaturePadHandler
                ? this._onShouldShowSignaturePad
                : undefined
            }
            hasShouldShowSignaturePad={hasSignaturePadHandler}
          />
        );
      }
    } else {
      return null;
    }
  }

  /**
   * @ignore
   */
  _onStateChanged = event => {
    if (this.props.onStateChanged) {
      this.props.onStateChanged(event.nativeEvent);
    }
  };

  /**
   * @ignore
   */
  _onDocumentLoaded = event => {
    if (this.props.onDocumentLoaded) {
      this.props.onDocumentLoaded(event.nativeEvent);
    }
  };

  /**
   * @ignore
   */
  _onDocumentSaved = event => {
    if (this.props.onDocumentSaved) {
      this.props.onDocumentSaved(event.nativeEvent);
    }
  };

  /**
   * @ignore
   */
  _onDocumentSaveFailed = event => {
    if (this.props.onDocumentSaveFailed) {
      this.props.onDocumentSaveFailed(event.nativeEvent);
    }
  };

  /**
   * @ignore
   */
  _onDocumentLoadFailed = event => {
    if (this.props.onDocumentLoadFailed) {
      this.props.onDocumentLoadFailed(event.nativeEvent);
    }
  };

  /**
   * @ignore
   */
  _onAnnotationTapped = event => {
    if (this.props.onAnnotationTapped) {
      this.props.onAnnotationTapped(event.nativeEvent);
    }
  };

  /**
   * @ignore
   */
  _onAnnotationsChanged = event => {
    if (this.props.onAnnotationsChanged) {
      this.props.onAnnotationsChanged(event.nativeEvent);
    }
  };

  /**
   * @ignore
   */
  _onNavigationButtonClicked = event => {
    if (this.props.onNavigationButtonClicked) {
      this.props.onNavigationButtonClicked(event.nativeEvent);
    }
  };

  /**
   * @ignore
   */
  _onDataReturned = event => {
    let { requestId, result, error } = event.nativeEvent;
    let promise = this._requestMap[requestId];
    if (result !== undefined) {
      promise.resolve(result);
    } else {
      promise.reject(error);
    }
    this._requestMap.delete(requestId);
  };

  /**
   * @ignore
   */
  _onCustomToolbarButtonTapped = event => {
    if (this.props.onCustomToolbarButtonTapped) {
      this.props.onCustomToolbarButtonTapped(event.nativeEvent);
    }
  };

  /**
   * @ignore
   */
  _onCustomAnnotationContextualMenuItemTapped = event => {
    if (this.props.onCustomAnnotationContextualMenuItemTapped) {
      this.props.onCustomAnnotationContextualMenuItemTapped(event.nativeEvent);
    }
  };

  /**
   * @ignore
   */
  _onCustomTextSelectionContextualMenuItemTapped = event => {
    if (this.props.onCustomTextSelectionContextualMenuItemTapped) {
      this.props.onCustomTextSelectionContextualMenuItemTapped(
        event.nativeEvent,
      );
    }
  };

  /**
   * @ignore
   */
  _onReady = event => {
    if (this.props.onReady) {
      this.props.onReady(event.nativeEvent);
    }
  };

  /**
   * @ignore
   */
  _onShouldExecuteAction = event => {
    const payload = event && event.nativeEvent ? event.nativeEvent : event;
    if (this.props.onShouldExecuteAction) {
      this.props.onShouldExecuteAction(payload);
    }
  };

  /**
   * @ignore
   */
  _onShouldShowSignaturePad = event => {
    const payload = event && event.nativeEvent ? event.nativeEvent : event;
    if (this.props.onShouldShowSignaturePad) {
      this.props.onShouldShowSignaturePad(payload);
    }
  };

  /**
   * Enters annotation creation mode, showing the annotation creation toolbar.
   * @method enterAnnotationCreationMode
   * @param { Annotation.Type } [annotationType] The annotation type that should be pre-selected when entering annotation creation mode.
   * @example
   * this.pdfRef.current.enterAnnotationCreationMode();
   * @memberof NutrientView
   */
  enterAnnotationCreationMode = function (annotationType) {
    // Architecture detection via helper function
    const { isNewArchitectureEnabled } = require('./lib/ArchitectureDetector');
    if (isNewArchitectureEnabled()) {
      // Delegate to Fabric component
      return this._fabricRef.current?.enterAnnotationCreationMode(
        annotationType,
      );
    }

    if (Platform.OS === 'android') {
      let requestId = this._nextRequestId++;
      let requestMap = this._requestMap;

      let promise = new Promise(function (resolve, reject) {
        requestMap[requestId] = { resolve: resolve, reject: reject };
      });

      UIManager.dispatchViewManagerCommand(
        findNodeHandle(this._componentRef.current),
        this._getViewManagerConfig('RCTPSPDFKitView').Commands
          .enterAnnotationCreationMode,
        [requestId, annotationType],
      );
    } else if (Platform.OS === 'ios') {
      return NativeModules.PSPDFKitViewManager.enterAnnotationCreationMode(
        annotationType,
        findNodeHandle(this._componentRef.current),
      );
    }
  };

  /**
   * Decides whether a previously intercepted PDF action (for example, a link tap)
   * should be executed by the native SDK.
   * Invoke this in response to the ```onShouldExecuteAction``` callback.
   *
   * @method executeAction
   * @param {string} requestId The request identifier received from the shouldExecuteAction callback.
   * @param {boolean} allow Whether the action should be executed (true) or cancelled (false).
   * @memberof NutrientView
   */
  executeAction = function (requestId, allow) {
    const { isNewArchitectureEnabled } = require('./lib/ArchitectureDetector');
    if (isNewArchitectureEnabled()) {
      // Delegate to Fabric component
      return this._fabricRef.current?.executeAction(requestId, allow);
    }

    if (Platform.OS === 'android') {
      // Legacy Android: fire-and-forget command. No Promise result is returned.
      UIManager.dispatchViewManagerCommand(
        findNodeHandle(this._componentRef.current),
        this._getViewManagerConfig('RCTPSPDFKitView').Commands.executeAction,
        [requestId, allow],
      );
      return;
    } else if (Platform.OS === 'ios') {
      // Legacy iOS: Promise-based module method.
      return NativeModules.PSPDFKitViewManager.executeAction(
        requestId,
        allow,
        findNodeHandle(this._componentRef.current),
      );
    }
  };

  /**
   * Decides whether a previously intercepted signature UI presentation should proceed.
   * Invoke this in response to the ```onShouldShowSignaturePad``` callback.
   *
   * @method showSignaturePad
   * @param {string} requestId The request identifier received from the onShouldShowSignaturePad callback.
   * @param {boolean} allow Whether the signature UI should be shown (true) or stay suppressed (false).
   * @memberof NutrientView
   * @returns { Promise<boolean> } A promise resolving to ```true``` if the request identifier was known and handled, ```false``` otherwise.
   */
  showSignaturePad = function (requestId, allow) {
    const { isNewArchitectureEnabled } = require('./lib/ArchitectureDetector');
    if (isNewArchitectureEnabled()) {
      // Delegate to Fabric component
      return this._fabricRef.current?.showSignaturePad(requestId, allow);
    }

    if (Platform.OS === 'android') {
      // Legacy Android: request-id-keyed command; resolves with the native result.
      return this._dispatchLegacyViewportCommand('showSignaturePad', [
        requestId,
        allow,
      ]);
    } else if (Platform.OS === 'ios') {
      // Legacy iOS: Promise-based module method.
      return NativeModules.PSPDFKitViewManager.showSignaturePad(
        requestId,
        allow,
        findNodeHandle(this._componentRef.current),
      );
    }
  };

  /**
   * Dismisses the signature UI if it is currently presented.
   *
   * @method dismissSignaturePad
   * @example
   * const didDismiss = await this.pdfRef.current.dismissSignaturePad();
   * @memberof NutrientView
   * @returns { Promise<boolean> } A promise resolving to ```true``` if a signature UI was showing and got dismissed, ```false``` if none was showing.
   */
  dismissSignaturePad = function () {
    const { isNewArchitectureEnabled } = require('./lib/ArchitectureDetector');
    if (isNewArchitectureEnabled()) {
      // Delegate to Fabric component
      return this._fabricRef.current?.dismissSignaturePad();
    }

    if (Platform.OS === 'android') {
      // Legacy Android: request-id-keyed command; resolves with the native result.
      return this._dispatchLegacyViewportCommand('dismissSignaturePad', []);
    } else if (Platform.OS === 'ios') {
      // Legacy iOS: Promise-based module method.
      return NativeModules.PSPDFKitViewManager.dismissSignaturePad(
        findNodeHandle(this._componentRef.current),
      );
    }
  };

  /**
   * Enters content editing mode, showing the content editing UI.
   * @method enterContentEditingMode
   * @example
   * this.pdfRef.current.enterContentEditingMode();
   * @memberof NutrientView
   */
  enterContentEditingMode = function () {
    // Architecture detection via helper function
    const { isNewArchitectureEnabled } = require('./lib/ArchitectureDetector');
    if (isNewArchitectureEnabled()) {
      // Delegate to Fabric component
      return this._fabricRef.current?.enterContentEditingMode();
    }

    if (Platform.OS === 'android') {
      let requestId = this._nextRequestId++;
      let requestMap = this._requestMap;

      let promise = new Promise(function (resolve, reject) {
        requestMap[requestId] = { resolve: resolve, reject: reject };
      });

      UIManager.dispatchViewManagerCommand(
        findNodeHandle(this._componentRef.current),
        this._getViewManagerConfig('RCTPSPDFKitView').Commands
          .enterContentEditingMode,
        [requestId],
      );
      return promise;
    } else if (Platform.OS === 'ios') {
      return NativeModules.PSPDFKitViewManager.enterContentEditingMode(
        findNodeHandle(this._componentRef.current),
      );
    }
  };

  /**
   * Exits the currently active mode, hiding all toolbars.
   * @method exitCurrentlyActiveMode
   * @example
   * this.pdfRef.current.exitCurrentlyActiveMode();
   * @memberof NutrientView
   */
  exitCurrentlyActiveMode = function () {
    // Architecture detection via helper function
    const { isNewArchitectureEnabled } = require('./lib/ArchitectureDetector');
    if (isNewArchitectureEnabled()) {
      // Delegate to Fabric component
      return this._fabricRef.current?.exitCurrentlyActiveMode();
    }

    if (Platform.OS === 'android') {
      let requestId = this._nextRequestId++;
      let requestMap = this._requestMap;

      let promise = new Promise(function (resolve, reject) {
        requestMap[requestId] = { resolve: resolve, reject: reject };
      });

      UIManager.dispatchViewManagerCommand(
        findNodeHandle(this._componentRef.current),
        this._getViewManagerConfig('RCTPSPDFKitView').Commands
          .exitCurrentlyActiveMode,
        [requestId],
      );
    } else if (Platform.OS === 'ios') {
      return NativeModules.PSPDFKitViewManager.exitCurrentlyActiveMode(
        findNodeHandle(this._componentRef.current),
      );
    }
  };

  /**
   * Saves the document that's currently open.
   * @deprecated Since Nutrient React Native SDK 2.12. Use ```this.pdfRef.current?.getDocument().save()``` instead.
   * See {@link https://nutrient.io/api/react-native/PDFDocument.html#.save|save()}.
   * @method saveCurrentDocument
   * @memberof NutrientView
   * @example
   * const result = await this.pdfRef.current.saveCurrentDocument();
   *
   * @returns { Promise<boolean> } A promise resolving to ```true``` if the document was saved, and ```false``` if not.
   */
  saveCurrentDocument = function () {
    // Architecture detection via helper function
    const { isNewArchitectureEnabled } = require('./lib/ArchitectureDetector');
    if (isNewArchitectureEnabled()) {
      // Delegate to Fabric component
      return this._fabricRef.current?.saveCurrentDocument();
    }

    if (Platform.OS === 'android') {
      let requestId = this._nextRequestId++;
      let requestMap = this._requestMap;

      // We create a promise here that will be resolved once onDataReturned is called.
      let promise = new Promise(function (resolve, reject) {
        requestMap[requestId] = { resolve: resolve, reject: reject };
      });

      UIManager.dispatchViewManagerCommand(
        findNodeHandle(this._componentRef.current),
        this._getViewManagerConfig('RCTPSPDFKitView').Commands
          .saveCurrentDocument,
        [requestId],
      );

      return promise;
    } else if (Platform.OS === 'ios') {
      return NativeModules.PSPDFKitViewManager.saveCurrentDocument(
        findNodeHandle(this._componentRef.current),
      );
    }
  };

  /**
   * Get the current PDF document.
   * @method getDocument
   * @example
   * const document = this.pdfRef.current?.getDocument();
   * @see {@link https://nutrient.io/api/react-native/PDFDocument.html} for available methods.
   * @memberof NutrientView
   * @returns { PDFDocument } A reference to the document that is currently loaded in the NutrientView component.
   */
  getDocument() {
    // Architecture detection via helper function
    const { isNewArchitectureEnabled } = require('./lib/ArchitectureDetector');
    if (isNewArchitectureEnabled()) {
      // Delegate to Fabric component ref
      return this._fabricRef.current?.getDocument();
    }
    if (this._pdfDocument == null) {
      this._pdfDocument = new PDFDocument(this._componentRef.current);
      return this._pdfDocument;
    } else {
      return this._pdfDocument;
    }
  }

  /**
   * Get the current Notification Center.
   * @method getNotificationCenter
   * @example
   * const document = this.pdfRef.current?.getNotificationCenter();
   * @see {@link https://nutrient.io/api/react-native/NotificationCenter.html} for available methods.
   * @memberof NutrientView
   * @returns { NotificationCenter } A reference to the Notification Center that can be used to subscribe and unsubscribe from events.
   */
  getNotificationCenter() {
    // Architecture detection via helper function
    const { isNewArchitectureEnabled } = require('./lib/ArchitectureDetector');
    if (isNewArchitectureEnabled()) {
      // Delegate to Fabric component ref
      return this._fabricRef.current?.getNotificationCenter();
    }
    if (this._notificationCenter == null) {
      this._notificationCenter = new NotificationCenter(
        this._componentRef.current,
      );
      return this._notificationCenter;
    } else {
      return this._notificationCenter;
    }
  }

  /**
   * @method clearSelectedAnnotations
   * @memberof NutrientView
   * @deprecated Since Nutrient React Native SDK 4.2. Use ```this.pdfRef.current?.getDocument().clearSelectedAnnotations()``` instead.
   * @description Clears all currently selected Annotations.
   * @example
   * const result = await this.pdfRef.current?.clearSelectedAnnotations();
   * @returns { Promise<any> } A promise containing the result of the operation. ```true``` if the annotations selection were cleared, ```false``` otherwise.
   */
  clearSelectedAnnotations = function () {
    const { isNewArchitectureEnabled } = require('./lib/ArchitectureDetector');
    if (isNewArchitectureEnabled()) {
      const document = this.getDocument?.();
      if (!document) {
        return Promise.reject(new Error('PDF document is not available'));
      }
      return document.clearSelectedAnnotations();
    }

    const ref =
      findNodeHandle(this._componentRef.current) ?? this._componentRef.current;
    if (ref == null) {
      return Promise.reject(new Error('PDF view reference is not available'));
    }
    return NativeModules.PDFDocumentManager.clearSelectedAnnotations(ref);
  };

  /**
   * @method selectAnnotations
   * @memberof NutrientView
   * @deprecated Since Nutrient React Native SDK 4.2. Use ```this.pdfRef.current?.getDocument().selectAnnotations(annotations, showContextualMenu)``` instead.
   * @param { object } annotations An array of the annotations to select in Instant JSON format.
   * @param { boolean } [showContextualMenu] Whether the annotation contextual menu should be shown after selection.
   * @description Select one or more annotations.
   * @example
   * const result = await this.pdfRef.current?.selectAnnotations(annotations);
   * @returns { Promise<boolean> } A promise containing the result of the operation. ```true``` if the annotations were selected, ```false``` otherwise.
   */
  selectAnnotations = function (annotations, showContextualMenu = false) {
    const { isNewArchitectureEnabled } = require('./lib/ArchitectureDetector');
    if (isNewArchitectureEnabled()) {
      const document = this.getDocument?.();
      if (!document) {
        return Promise.reject(new Error('PDF document is not available'));
      }
      return document.selectAnnotations(annotations, showContextualMenu);
    }

    const ref =
      findNodeHandle(this._componentRef.current) ?? this._componentRef.current;
    if (ref == null) {
      return Promise.reject(new Error('PDF view reference is not available'));
    }
    return NativeModules.PDFDocumentManager.selectAnnotations(
      ref,
      annotations,
      showContextualMenu,
    );
  };

  /**
   * @typedef FormFieldResult
   * @property { string } [formElement] The form field value
   * @property { string } [error] The error description
   */

  /**
   * Gets the form field value of the supplied form field name.
   *
   * @method getFormFieldValue
   * @memberof NutrientView
   * @param { string } fullyQualifiedName The fully qualified name of the form element.
   * @deprecated Since Nutrient React Native SDK 2.17. Use the ```getFormElements``` API on the ```PDFDocument.forms``` object instead, and filter by ```fullyQualifiedFieldName```.
   * @example
   * const result = await this.pdfRef.current.getFormFieldValue('myFormElement');
   * // result: {'myFormElement' : value}
   * // or
   * // {'error' : 'Failed to get the form field value.'}
   *
   * @returns { Promise<FormFieldResult> } A promise containing an object with the value, or an error if the form field could not be found.
   */
  getFormFieldValue = function (fullyQualifiedName) {
    if (Platform.OS === 'android') {
      let requestId = this._nextRequestId++;
      let requestMap = this._requestMap;

      // We create a promise here that will be resolved once onDataReturned is called.
      let promise = new Promise(function (resolve, reject) {
        requestMap[requestId] = { resolve: resolve, reject: reject };
      });

      UIManager.dispatchViewManagerCommand(
        findNodeHandle(this._componentRef.current),
        this._getViewManagerConfig('RCTPSPDFKitView').Commands
          .getFormFieldValue,
        [requestId, fullyQualifiedName],
      );

      return promise;
    } else if (Platform.OS === 'ios') {
      return NativeModules.PSPDFKitViewManager.getFormFieldValue(
        fullyQualifiedName,
        findNodeHandle(this._componentRef.current),
      );
    }
  };

  /**
   * Sets the form field value of the supplied form field name.
   *
   * @method setFormFieldValue
   * @memberof NutrientView
   * @param { string } fullyQualifiedName The fully qualified name of the form element. When using form elements such as radio buttons, the individual elements can be accessed by appending the index to the fully qualified name, for example ```choiceElement.0``` and ```choiceElement.1```.
   * @param { string } value The new string value of the form element. For button form elements, pass ```selected``` or ```deselected```. For choice form elements, pass the index of the choice to select, for example ```1```.
   * @deprecated Since Nutrient React Native SDK 2.17. Use one of the ```update``` APIs on the ```PDFDocument.forms``` object instead.
   * @example
   * const result = await this.pdfRef.current.setFormFieldValue('Name_Last', 'Appleseed');
   *
   * @returns { Promise<boolean> } A promise resolving to ```true``` if the value was set successfully, and ```false``` if an error occurred.
   */
  setFormFieldValue = function (fullyQualifiedName, value) {
    if (Platform.OS === 'android') {
      let requestId = this._nextRequestId++;
      let requestMap = this._requestMap;

      // We create a promise here that will be resolved once onDataReturned is called.
      let promise = new Promise(function (resolve, reject) {
        requestMap[requestId] = { resolve: resolve, reject: reject };
      });

      UIManager.dispatchViewManagerCommand(
        findNodeHandle(this._componentRef.current),
        this._getViewManagerConfig('RCTPSPDFKitView').Commands
          .setFormFieldValue,
        [requestId, fullyQualifiedName, value],
      );

      return promise;
    } else if (Platform.OS === 'ios') {
      return NativeModules.PSPDFKitViewManager.setFormFieldValue(
        value,
        fullyQualifiedName,
        findNodeHandle(this._componentRef.current),
      );
    }
  };

  /**
   * Sets the left bar button items for the specified view mode.
   * Note: The same button item cannot be added to both the left and right bar button items simultaneously.
   *
   * @method setLeftBarButtonItems
   * @memberof NutrientView
   * @param { Array<string> } items The list of bar button items.
   * @deprecated Since Nutrient React Native SDK 4.0. Use ```this.pdfRef.current?.setToolbar()``` instead.
   * @see {@link https://github.com/PSPDFKit/react-native/blob/master/ios/Converters/RCTConvert+UIBarButtonItem.m} for supported button items.
   * @param { string } [viewMode] The view mode for which the bar buttons should be set. Options are: ```document```, ```thumbnails```, ```documentEditor```, or ```null```. If ```null``` is passed, the bar button items for all the view modes are set.
   * @param { boolean } [animated] Specifies whether changing the bar buttons should be animated.
   * @example
   * const result = await this.pdfRef.current.setLeftBarButtonItems(
   *    ['searchButtonItem', 'thumbnailsButtonItem'],
   *    'document',
   *    true);
   *
   */
  setLeftBarButtonItems = function (items, viewMode, animated) {
    if (Platform.OS === 'ios') {
      NativeModules.PSPDFKitViewManager.setLeftBarButtonItems(
        items,
        viewMode,
        animated,
        findNodeHandle(this._componentRef.current),
      );
    }
  };

  /**
   * Gets the left bar button items for the specified view mode.
   *
   * @method getLeftBarButtonItemsForViewMode
   * @memberof NutrientView
   * @param { string } [viewMode] The view mode to query. Options are: ```document```, ```thumbnails```, ```documentEditor```, or ```null```. If ```null``` is passed, the bar button items for the current view mode are returned.
   * @deprecated Since Nutrient React Native SDK 4.0. Use ```this.pdfRef.current?.getToolbar()``` instead.
   * @returns { Promise<Array<string>> } A promise containing an array of bar button items, or an error if the items couldn't be retrieved.
   * @example
   * const leftBarButtonItems = await this.pdfRef.current.getLeftBarButtonItemsForViewMode('document');
   * // leftBarButtonItems: ['outlineButtonItem', 'searchButtonItem']
   * // or
   * // {'error' : 'Failed to get the left bar button items.'}
   *
   */
  getLeftBarButtonItemsForViewMode = function (viewMode) {
    if (Platform.OS === 'ios') {
      return NativeModules.PSPDFKitViewManager.getLeftBarButtonItemsForViewMode(
        viewMode,
        findNodeHandle(this._componentRef.current),
      );
    }
  };

  /**
   * Sets the right bar button items for the specified view mode.
   * Note: The same button item cannot be added to both the left and right bar button items simultaneously.
   *
   * @method setRightBarButtonItems
   * @memberof NutrientView
   * @param { Array<string> } items The list of bar button items.
   * @deprecated Since Nutrient React Native SDK 4.0. Use ```this.pdfRef.current?.setToolbar()``` instead.
   * @see {@link https://github.com/PSPDFKit/react-native/blob/master/ios/Converters/RCTConvert+UIBarButtonItem.m} for supported button items.
   * @param { string } [viewMode] The view mode for which the bar buttons should be set. Options are: ```document```, ```thumbnails```, ```documentEditor```, or ```null```. If ```null``` is passed, the bar button items for all the view modes are set.
   * @param { boolean } [animated] Specifies whether changing the bar buttons should be animated.
   * @example
   * const result = await this.pdfRef.current.setRightBarButtonItems(
   *    ['searchButtonItem', 'thumbnailsButtonItem'],
   *    'document',
   *    true);
   *
   */
  setRightBarButtonItems = function (items, viewMode, animated) {
    if (Platform.OS === 'ios') {
      NativeModules.PSPDFKitViewManager.setRightBarButtonItems(
        items,
        viewMode,
        animated,
        findNodeHandle(this._componentRef.current),
      );
    }
  };

  /**
   * Gets the right bar button items for the specified view mode.
   *
   * @method getRightBarButtonItemsForViewMode
   * @memberof NutrientView
   * @param { string } [viewMode] The view mode to query. Options are: ```document```, ```thumbnails```, ```documentEditor```, or ```null```. If ```null``` is passed, the bar button items for the current view mode are returned.
   * @deprecated Since Nutrient React Native SDK 4.0. Use ```this.pdfRef.current?.getToolbar()``` instead.
   * @returns { Promise<Array<string>> } A promise containing an array of bar button items, or an error if the items couldn't be retrieved.
   * @example
   * const rightBarButtonItems = await this.pdfRef.current.getRightBarButtonItemsForViewMode('document');
   * // rightBarButtonItems: ['outlineButtonItem', 'searchButtonItem']
   * // or
   * // {'error' : 'Failed to get the right bar button items.'}
   *
   */
  getRightBarButtonItemsForViewMode = function (viewMode) {
    if (Platform.OS === 'ios') {
      return NativeModules.PSPDFKitViewManager.getRightBarButtonItemsForViewMode(
        viewMode,
        findNodeHandle(this._componentRef.current),
      );
    }
  };

  /**
   * Sets the Toolbar object to customize the toolbar appearance and behaviour.
   *
   * @method setToolbar
   * @memberof NutrientView
   * @param { Toolbar } toolbar The toolbar object.
   * @example
   * const toolbar = {
   *		// iOS
   *		rightBarButtonItems: {
   *		  viewMode: Toolbar.PDFViewMode.VIEW_MODE_DOCUMENT,
   *		  animated: true,
   *		  buttons: ['searchButtonItem', 'readerViewButtonItem']
   *		},
   *		// Android
   *		toolbarMenuItems: {
   *		  buttons: ['searchButtonItem', 'readerViewButtonItem']
   *	  },
   *	}
   *	this.pdfRef.current.setToolbar(toolbar);
   *
   */
  setToolbar = function (toolbar) {
    // Architecture detection via helper function
    const { isNewArchitectureEnabled } = require('./lib/ArchitectureDetector');
    if (isNewArchitectureEnabled()) {
      // Delegate to Fabric component
      return this._fabricRef.current?.setToolbar(toolbar);
    }

    if (Platform.OS === 'ios') {
      NativeModules.PSPDFKitViewManager.setToolbar(
        toolbar,
        findNodeHandle(this._componentRef.current),
      );
    } else if (Platform.OS === 'android') {
      UIManager.dispatchViewManagerCommand(
        findNodeHandle(this._componentRef.current),
        this._getViewManagerConfig('RCTPSPDFKitView').Commands.setToolbar,
        [toolbar],
      );
    }
  };

  /**
   * Gets the toolbar for the specified view mode.
   *
   * @method getToolbar
   * @memberof NutrientView
   * @param { string } [viewMode] The view mode to query. Options are: ```document```, ```thumbnails```, ```documentEditor```, or ```null```. If ```null``` is passed, the toolbar buttons for the current view mode are returned.
   *
   * @returns { Promise<Array<string>> } A promise containing the toolbar object, or an error if it couldn't be retrieved.
   * @example
   * const toolbar = await this.pdfRef.current.getToolbar('document');
   *
   */
  getToolbar = function (viewMode) {
    // Architecture detection via helper function
    const { isNewArchitectureEnabled } = require('./lib/ArchitectureDetector');
    if (isNewArchitectureEnabled()) {
      // Delegate to Fabric component
      return this._fabricRef.current?.getToolbar(viewMode);
    }

    if (Platform.OS === 'ios') {
      return NativeModules.PSPDFKitViewManager.getToolbar(
        viewMode,
        findNodeHandle(this._componentRef.current),
      );
    }
  };

  /**
   * Sets the measurement value configurations for the ```NutrientView```.
   *
   * @method setMeasurementValueConfigurations
   * @memberof NutrientView
   * @param { MeasurementValueConfiguration[] } configurations The array of ```MeasurementValueConfiguration``` objects that should be applied to the document.
   * @returns { Promise<boolean> } A promise containing the result of the operation.
   * @example
   * const scale: MeasurementScale = {
   *    unitFrom: Measurements.ScaleUnitFrom.INCH,
   *    valueFrom: 1.0,
   *    unitTo: Measurements.ScaleUnitTo.INCH,
   *    valueTo: 2.54
   *  };
   *
   *  const measurementValueConfig: MeasurementValueConfiguration = {
   *    name: 'Custom Scale',
   *    scale: scale,
   *    precision: Measurements.Precision.FOUR_DP
   *  };
   *
   *  const configs = [measurementValueConfig];
   *  await this.pdfRef.current?.setMeasurementValueConfigurations(configs);
   */
  setMeasurementValueConfigurations = function (configurations) {
    // Architecture detection via helper function
    const { isNewArchitectureEnabled } = require('./lib/ArchitectureDetector');
    if (isNewArchitectureEnabled()) {
      // Delegate to Fabric component
      return this._fabricRef.current?.setMeasurementValueConfigurations(
        configurations,
      );
    }

    if (Platform.OS === 'android') {
      let requestId = this._nextRequestId++;
      let requestMap = this._requestMap;

      // We create a promise here that will be resolved once onDataReturned is called.
      let promise = new Promise(function (resolve, reject) {
        requestMap[requestId] = { resolve: resolve, reject: reject };
      });

      UIManager.dispatchViewManagerCommand(
        findNodeHandle(this._componentRef.current),
        this._getViewManagerConfig('RCTPSPDFKitView').Commands
          .setMeasurementValueConfigurations,
        [requestId, configurations],
      );

      return promise;
    }

    NativeModules.PSPDFKitViewManager.setMeasurementValueConfigurations(
      configurations,
      findNodeHandle(this._componentRef.current),
    );
  };

  /**
   * Gets the current NutrientView MeasurementValueConfigurations.
   *
   * @method getMeasurementValueConfigurations
   * @memberof NutrientView
   *
   * @returns { Promise<MeasurementValueConfiguration[]> } A promise containing an array of ```MeasurementValueConfiguration``` objects.
   * @example
   * const configurations = await this.pdfRef.current.getMeasurementValueConfigurations();
   */
  getMeasurementValueConfigurations = function () {
    // Architecture detection via helper function
    const { isNewArchitectureEnabled } = require('./lib/ArchitectureDetector');
    if (isNewArchitectureEnabled()) {
      // Delegate to Fabric component
      return this._fabricRef.current?.getMeasurementValueConfigurations();
    }

    if (Platform.OS === 'android') {
      let requestId = this._nextRequestId++;
      let requestMap = this._requestMap;

      // We create a promise here that will be resolved once onDataReturned is called.
      let promise = new Promise(function (resolve, reject) {
        requestMap[requestId] = { resolve: resolve, reject: reject };
      });

      UIManager.dispatchViewManagerCommand(
        findNodeHandle(this._componentRef.current),
        this._getViewManagerConfig('RCTPSPDFKitView').Commands
          .getMeasurementValueConfigurations,
        [requestId],
      );

      return promise;
    } else if (Platform.OS === 'ios') {
      return NativeModules.PSPDFKitViewManager.getMeasurementValueConfigurations(
        findNodeHandle(this._componentRef.current),
      );
    }
  };

  /**
   * Customizes the visible toolbar menu items for Android.
   *
   * @method setToolbarMenuItems
   * @memberof NutrientView
   * @param { Array<string> } toolbarMenuItems The list of bar button items.
   * @deprecated Since Nutrient React Native SDK 4.0. Use ```this.pdfRef.current?.setToolbar()``` instead.
   * @see {@link https://nutrient.io/guides/react-native/user-interface/toolbars/main-toolbar/} for supported button items.
   * @example
   * const result = await this.pdfRef.current.setToolbarMenuItems(['searchButtonItem', 'readerViewButtonItem']);
   *
   */
  setToolbarMenuItems = function (toolbarMenuItems) {
    if (Platform.OS === 'android') {
      UIManager.dispatchViewManagerCommand(
        findNodeHandle(this._componentRef.current),
        this._getViewManagerConfig('RCTPSPDFKitView').Commands
          .setToolbarMenuItems,
        [toolbarMenuItems],
      );
    }
  };

  /**
   * Gets the current NutrientView configuration.
   *
   * @method getConfiguration
   * @memberof NutrientView
   *
   * @returns { Promise<PDFConfiguration> } A promise containing a ```PDFConfiguration``` object with the document configuration.
   * @example
   * const configuration = await this.pdfRef.current.getConfiguration();
   */
  getConfiguration = function () {
    // Architecture detection via helper function
    const { isNewArchitectureEnabled } = require('./lib/ArchitectureDetector');
    if (isNewArchitectureEnabled()) {
      // Delegate to Fabric component
      return this._fabricRef.current?.getConfiguration();
    }

    if (Platform.OS === 'android') {
      let requestId = this._nextRequestId++;
      let requestMap = this._requestMap;

      // We create a promise here that will be resolved once onDataReturned is called.
      let promise = new Promise(function (resolve, reject) {
        requestMap[requestId] = { resolve: resolve, reject: reject };
      });

      UIManager.dispatchViewManagerCommand(
        findNodeHandle(this._componentRef.current),
        this._getViewManagerConfig('RCTPSPDFKitView').Commands.getConfiguration,
        [requestId],
      );

      return promise;
    } else if (Platform.OS === 'ios') {
      return NativeModules.PSPDFKitViewManager.getConfiguration(
        findNodeHandle(this._componentRef.current),
      );
    }
  };

  /**
   * @typedef Point
   * @property { number } x The x coordinate.
   * @property { number } y The y coordinate.
   */

  /**
   * @typedef Rect
   * @property { number } x The x coordinate of the origin.
   * @property { number } y The y coordinate of the origin.
   * @property { number } width The width of the rectangle.
   * @property { number } height The height of the rectangle.
   */

  /**
   * @typedef DocumentViewportChangedPayload
   * @property { 'documentViewportChanged' } event Name of the event.
   * @property { string } documentID Identifier of the document currently displayed.
   * @property { number } pageIndex The primary (most visible) page index for which ```visiblePdfRect``` is reported.
   * @property { number } zoomScale Current zoom factor of the view, relative to the zoom level at
   * which the page fits the viewport, so it is ```1``` at the fitting zoom level. This is not the
   * ratio between PDF points and screen points: use ```pdfToScreenScale``` for that.
   * @property { number } pdfToScreenScale Screen points per PDF point on ```pageIndex``` at the
   * current zoom level. Multiplying a distance in PDF points by this value gives the distance on screen.
   * @property { Rect } visiblePdfRect Visible region of ```pageIndex```, expressed in PDF points and
   * clipped to the page, so it is never larger than ```pageSize``` and never has a negative origin.
   * Its origin is the PDF's bottom-left, so ```y``` is the distance from the bottom of the page. All
   * zeros while the reported page is momentarily off screen, which can happen for a frame or two
   * during a fling; the other fields stay valid.
   * @property { object } pageSize Size of ```pageIndex```, in PDF points. Accounts for page rotation.
   * @property { number } pageSize.width The width of the page.
   * @property { number } pageSize.height The height of the page.
   * @property { Point } contentOffset Content offset of the scroll view, in screen points,
   * relative to ```pageIndex```'s top-left. Since ```pageIndex``` is whichever page is
   * currently anchored (closest to the center of the viewport), this jumps discontinuously
   * when the anchor page changes, e.g. scrolling past a page boundary. It is not a
   * document-absolute offset; use ```visiblePdfRect``` and ```pageIndex``` together if you
   * need position relative to a specific page instead.
   * @property { object } viewportSize Size of the viewport, in screen points.
   * @property { number } viewportSize.width The width of the viewport.
   * @property { number } viewportSize.height The height of the viewport.
   */

  /**
   * Dispatches a legacy-bridge command by name and awaits its request-id-keyed
   * response. Shared by the viewport/coordinate and signature-pad methods, which
   * differ only in command name and arguments.
   */
  _dispatchLegacyViewportCommand = function (commandName, commandArgs) {
    let requestId = this._nextRequestId++;
    let requestMap = this._requestMap;
    let promise = new Promise(function (resolve, reject) {
      requestMap[requestId] = { resolve: resolve, reject: reject };
    });
    UIManager.dispatchViewManagerCommand(
      findNodeHandle(this._componentRef.current),
      this._getViewManagerConfig('RCTPSPDFKitView').Commands[commandName],
      [requestId, ...commandArgs],
    );
    return promise;
  };

  /**
   * Runs a viewport/coordinate method on whichever architecture/platform path applies,
   * rejecting instead of silently returning `undefined` when none does (e.g. the Fabric
   * ref isn't attached yet, or the method is called on an unsupported platform).
   */
  _invokeViewportMethod = function (
    methodName,
    fabricArgs,
    legacyCommandArgs,
    iosArgs,
  ) {
    const { isNewArchitectureEnabled } = require('./lib/ArchitectureDetector');
    if (isNewArchitectureEnabled()) {
      if (!this._fabricRef.current) {
        return Promise.reject(
          new Error(
            `NutrientView.${methodName}: the native view is not ready yet.`,
          ),
        );
      }
      return this._fabricRef.current[methodName](...fabricArgs);
    }

    if (Platform.OS === 'android') {
      return this._dispatchLegacyViewportCommand(methodName, legacyCommandArgs);
    } else if (Platform.OS === 'ios') {
      return NativeModules.PSPDFKitViewManager[methodName](
        ...iosArgs,
        findNodeHandle(this._componentRef.current),
      );
    }
    return Promise.reject(
      new Error(
        `NutrientView.${methodName} is not supported on platform "${Platform.OS}".`,
      ),
    );
  };

  /**
   * Converts a point in PDF coordinates (for the given page) to screen coordinates,
   * in points, relative to the ```NutrientView```'s frame origin. Useful for positioning
   * custom overlays on top of the rendered document.
   *
   * @method convertPointToScreen
   * @memberof NutrientView
   * @param {number} pageIndex The index of the page the point belongs to. Starts at 0.
   * @param {Point} point The point in PDF coordinates, e.g. ```{ x: 100, y: 200 }```.
   * @returns { Promise<Point> } A promise resolving to the point in screen coordinates.
   * @example
   * const screenPoint = await this.pdfRef.current?.convertPointToScreen(0, { x: 100, y: 200 });
   */
  convertPointToScreen = function (pageIndex, point) {
    return this._invokeViewportMethod(
      'convertPointToScreen',
      [pageIndex, point],
      [pageIndex, point],
      [pageIndex, point],
    );
  };

  /**
   * Converts a point in screen coordinates (in points, relative to the ```NutrientView```'s
   * frame origin) to PDF coordinates for the given page.
   *
   * @method convertPointToPage
   * @memberof NutrientView
   * @param {number} pageIndex The index of the page the point belongs to. Starts at 0.
   * @param {Point} point The point in screen coordinates, e.g. ```{ x: 50, y: 120 }```.
   * @returns { Promise<Point> } A promise resolving to the point in PDF coordinates.
   * @example
   * const pdfPoint = await this.pdfRef.current?.convertPointToPage(0, { x: 50, y: 120 });
   */
  convertPointToPage = function (pageIndex, point) {
    return this._invokeViewportMethod(
      'convertPointToPage',
      [pageIndex, point],
      [pageIndex, point],
      [pageIndex, point],
    );
  };

  /**
   * Converts a rectangle in PDF coordinates (for the given page) to screen coordinates,
   * in points, relative to the ```NutrientView```'s frame origin.
   *
   * @method convertRectToScreen
   * @memberof NutrientView
   * @param {number} pageIndex The index of the page the rectangle belongs to. Starts at 0.
   * @param {Rect} rect The rectangle in PDF coordinates, e.g. ```{ x: 100, y: 200, width: 50, height: 20 }```.
   * @returns { Promise<Rect> } A promise resolving to the rectangle in screen coordinates.
   * @example
   * const screenRect = await this.pdfRef.current?.convertRectToScreen(0, { x: 100, y: 200, width: 50, height: 20 });
   */
  convertRectToScreen = function (pageIndex, rect) {
    return this._invokeViewportMethod(
      'convertRectToScreen',
      [pageIndex, rect],
      [pageIndex, rect],
      [pageIndex, rect],
    );
  };

  /**
   * Converts a rectangle in screen coordinates (in points, relative to the ```NutrientView```'s
   * frame origin) to PDF coordinates for the given page.
   *
   * @method convertRectToPage
   * @memberof NutrientView
   * @param {number} pageIndex The index of the page the rectangle belongs to. Starts at 0.
   * @param {Rect} rect The rectangle in screen coordinates, e.g. ```{ x: 50, y: 120, width: 30, height: 10 }```.
   * @returns { Promise<Rect> } A promise resolving to the rectangle in PDF coordinates.
   * @example
   * const pdfRect = await this.pdfRef.current?.convertRectToPage(0, { x: 50, y: 120, width: 30, height: 10 });
   */
  convertRectToPage = function (pageIndex, rect) {
    return this._invokeViewportMethod(
      'convertRectToPage',
      [pageIndex, rect],
      [pageIndex, rect],
      [pageIndex, rect],
    );
  };

  /**
   * Returns a one-shot snapshot of the current viewport transformation state. This is the
   * same payload delivered by the ```documentViewportChanged``` notification, but pulled on demand.
   *
   * @method getViewportState
   * @memberof NutrientView
   * @returns { Promise<DocumentViewportChangedPayload> } A promise resolving to the current viewport state.
   * @example
   * const viewport = await this.pdfRef.current?.getViewportState();
   */
  getViewportState = function () {
    return this._invokeViewportMethod('getViewportState', [], [], []);
  };

  /**
   * Prevents the specified annotations from being interacted with.
   *
   * @method setExcludedAnnotations
   * @memberof NutrientView
   * @param {string[]} annotations The list of annotation UUIDs to exclude from annotation interaction.
   * @example
   * const result = await this.pdfRef.current?.setExcludedAnnotations(['A1FD2345-1234-1234-1234-123456789012']);
   * @returns { void }
   */
  setExcludedAnnotations = function (annotations) {
    // Architecture detection via helper function
    const { isNewArchitectureEnabled } = require('./lib/ArchitectureDetector');
    if (isNewArchitectureEnabled()) {
      // Delegate to Fabric component
      return this._fabricRef.current?.setExcludedAnnotations(annotations);
    }

    if (Platform.OS === 'ios') {
      NativeModules.PSPDFKitViewManager.setExcludedAnnotations(
        annotations,
        findNodeHandle(this._componentRef.current),
      );
    } else if (Platform.OS === 'android') {
      UIManager.dispatchViewManagerCommand(
        findNodeHandle(this._componentRef.current),
        this._getViewManagerConfig('RCTPSPDFKitView').Commands
          .setExcludedAnnotations,
        [annotations],
      );
    }
  };

  /**
   * Sets the visibility of the user interface controls.
   *
   * @method setUserInterfaceVisible
   * @memberof NutrientView
   * @param {boolean} visible Whether the user interface controls should be visible.
   * @example
   * const result = await this.pdfRef.current?.setUserInterfaceVisible(false);
   * @returns { Promise<boolean> } A promise containing the result of the operation. ```true``` if the visibility was set successfully, ```false``` otherwise.
   */
  setUserInterfaceVisible = function (visible) {
    // Architecture detection via helper function
    const { isNewArchitectureEnabled } = require('./lib/ArchitectureDetector');
    if (isNewArchitectureEnabled()) {
      // Delegate to Fabric component
      return this._fabricRef.current?.setUserInterfaceVisible(visible);
    }

    if (Platform.OS === 'android') {
      let requestId = this._nextRequestId++;
      let requestMap = this._requestMap;

      // We create a promise here that will be resolved once onDataReturned is called.
      let promise = new Promise(function (resolve, reject) {
        requestMap[requestId] = { resolve: resolve, reject: reject };
      });

      UIManager.dispatchViewManagerCommand(
        findNodeHandle(this._componentRef.current),
        this._getViewManagerConfig('RCTPSPDFKitView').Commands
          .setUserInterfaceVisible,
        [requestId, visible],
      );

      return promise;
    } else if (Platform.OS === 'ios') {
      return NativeModules.PSPDFKitViewManager.setUserInterfaceVisible(
        visible,
        findNodeHandle(this._componentRef.current),
      );
    }
  };

  /**
   * Removes the currently displayed Android Native ```PdfUiFragment```.
   * This function should only be used as a workaround for a bug in ```react-native-screen``` that causes a crash when
   * ```navigation.goBack()``` is called or a hardware back button is used to navigate back on Android. Calling this
   * function will prevent the crash by removing the fragment from the ```PdfView``` before the navigation takes place.
   *
   * @method destroyView
   * @memberof NutrientView
   *
   */
  destroyView = function () {
    // Architecture detection via helper function
    const { isNewArchitectureEnabled } = require('./lib/ArchitectureDetector');
    if (isNewArchitectureEnabled()) {
      // Delegate to Fabric component
      return this._fabricRef.current?.destroyView();
    }

    if (Platform.OS === 'android') {
      UIManager.dispatchViewManagerCommand(
        findNodeHandle(this._componentRef.current),
        this._getViewManagerConfig('RCTPSPDFKitView').Commands.removeFragment,
        [],
      );
    }
  };

  _getViewManagerConfig = viewManagerName => {
    return UIManager.getViewManagerConfig(viewManagerName);
  };
}

if (Platform.OS === 'ios' || Platform.OS === 'android') {
  var RCTPSPDFKitView = requireNativeComponent(
    'RCTPSPDFKitView',
    NutrientView,
    {
      nativeOnly: {
        testID: true,
        accessibilityComponentType: true,
        renderToHardwareTextureAndroid: true,
        accessibilityLabel: true,
        accessibilityLiveRegion: true,
        importantForAccessibility: true,
        onLayout: true,
        nativeID: true,
      },
    },
  );
  module.exports = NutrientView;
}

/**
 * NutrientInstantView is a React Native component for displaying Instant (real-time collaboration) PDF documents.
 * @augments {React.Component<Props, *>}
 * @hideconstructor
 * @example
 * <NutrientInstantView
 *   documentInfo={JSON.stringify({ serverUrl: 'https://...', jwt: '...' })}
 *   configuration={{ enableInstantComments: true }}
 *   ref={instantRef}
 *   style={{ flex: 1 }}
 * />
 */
class NutrientInstantView extends React.Component {
  static _isNewArchitecture = null;
  static _FabricComponent = null;
  static _warnedUnsupported = false;

  static _getArchitectureInfo() {
    if (this._isNewArchitecture === null) {
      try {
        const {
          isNewArchitectureEnabled,
        } = require('./lib/ArchitectureDetector');
        this._isNewArchitecture = isNewArchitectureEnabled();

        if (this._isNewArchitecture) {
          // Require from src/ so Metro can process codegen for NutrientInstantViewNativeComponent
          this._FabricComponent =
            require('./src/NutrientInstantViewFabric').default;
        }
      } catch (e) {
        this._isNewArchitecture = false;
        this._FabricComponent = null;
      }
    }
    return {
      isNewArchitecture: this._isNewArchitecture,
      FabricComponent: this._FabricComponent,
    };
  }

  _fabricRef = React.createRef();

  render() {
    const { isNewArchitecture, FabricComponent } =
      NutrientInstantView._getArchitectureInfo();
    if (isNewArchitecture && FabricComponent) {
      return React.createElement(FabricComponent, {
        ...this.props,
        ref: this._fabricRef,
      });
    }

    if (
      !NutrientInstantView._warnedUnsupported &&
      typeof console !== 'undefined' &&
      console.warn
    ) {
      NutrientInstantView._warnedUnsupported = true;
      console.warn(
        'NutrientInstantView is only supported with React Native New Architecture (Fabric). Enable New Architecture or use Nutrient.presentInstant() for full-screen Instant.',
      );
    }

    return null;
  }
}

/**
 * @ignore
 * @typedef {object} Props
 * @property {string} document The path to the PDF file that should be displayed.
 * @property {PDFConfiguration} [configuration] Configuration object to customize the appearance and behavior of Nutrient. See {@link https://nutrient.io/api/react-native/PDFConfiguration.html} for available options.
 * @property {Toolbar} [toolbar] Toolbar object to customize the toolbar appearance and behaviour.
 * @property {AnnotationContextualMenu} [annotationContextualMenu] Object to customize the menu shown when selecting an annotation.
 * @property {TextSelectionContextualMenu} [textSelectionContextualMenu] Object to customize the menu shown when selecting text.
 * @property {number} [pageIndex] Page index of the document that will be shown. Starts at 0.
 * @property {boolean} [hideNavigationBar] Controls whether a navigation bar is created and shown or not. Navigation bar is shown by default (```false```).
 * @property {boolean} [showCloseButton] Specifies whether the close button should be shown in the navigation bar. Disabled by default (```false```). Only applies when the ```NutrientView``` is presented modally. Will call ```onCloseButtonPressed``` when tapped if a callback was provided. If ```onCloseButtonPressed``` wasn't provided, ```NutrientView``` will automatically be dismissed when modally presented.
 * @property {boolean} [disableDefaultActionForTappedAnnotations] Controls whether or not the default action for tapped annotations is processed. Defaults to processing the action (```false```). Does not take precedence over the ```onShouldExecuteAction``` callback for annotation actions.
 * @property {boolean} [disableAutomaticSaving] Controls whether or not the document will automatically be saved. Defaults to automatically saving (```false```). Deprecated since Nutrient React Native SDK 4.0. Use ```disableDocumentEditing``` on the ```PDFConfiguration``` object instead.
 * @property {string} [annotationAuthorName] Controls the author name that's set for new annotations. If not set and the user hasn't specified it before, the user will be asked and the result will be saved. The value set here will be persisted and the user won't be asked, even if this isn't set the next time.
 * @property {string} [imageSaveMode] Specifies what is written back to the original image URL when the receiver is saved. If this property is ```flattenAndEmbed```, then this allows for changes made to the image to be saved as metadata in the original file. If the same file is reopened, all previous changes made will remain editable. If this property is ```flatten```, the changes are simply written to the image, and will not be editable when reopened. Available options are: ```flatten``` or ```flattenAndEmbed```.
 * @property {function} [onCloseButtonPressed] Callback that's called when the user tapped the close button. If you provide this function, you need to handle dismissal yourself. If you don't provide this function, ```NutrientView``` will be automatically dismissed. Only applies when the ```NutrientView``` is presented modally.
 * @property {function} [onDocumentLoaded] Callback that's called when the document is loaded in the ```NutrientView```.
 * @property {function} [onReady] Callback that's called when the ```NutrientView``` is ready. Use this callback start interacting with the ```PDFDocument``` object. Does not indicate a successful document load - use ```NotificationCenter.DocumentEvent.LOADED``` to monitor this.
 * @property {function} [onDocumentLoadFailed] Callback that's called when the document failed to load.
 * @property {function} [onDocumentSaved] Callback that's called when the document is saved.
 * @property {function} [onDocumentSaveFailed] Callback that's called when the document fails to save.
 * @property {function} [onAnnotationTapped] Callback that's called when an annotation is tapped.
 * @property {function} [onAnnotationsChanged] Callback that's called when an annotation is added, changed, or removed.
 * @property {function} [onStateChanged] Callback that's called when the state of the ```NutrientView``` changes.
 * @property {function} [onCustomToolbarButtonTapped] Callback that's called when a custom toolbar button is tapped.
 * @property {function} [onCustomAnnotationContextualMenuItemTapped] Callback that's called when a custom annotation menu item is tapped.
 * @property {function} [onCustomTextSelectionContextualMenuItemTapped] Callback that's called when a custom text selection menu item is tapped.
 * @property {function} [onShouldExecuteAction] Callback that's called just before the native SDK executes a PDF action (for example, when a link annotation is tapped). Use this to decide, via {@link NutrientView#executeAction}, whether the intercepted action should proceed.
 * @property {function} [onShouldShowSignaturePad] Callback that's called just before the native SDK presents the signature creation/selection UI for a tapped signature form field. Use this to decide, via {@link NutrientView#showSignaturePad}, whether the signature UI should be presented.
 * @property {string} [fragmentTag] The tag used to identify a single PdfFragment in the view hierarchy. This needs to be unique in the view hierarchy.
 * @property {Array} [menuItemGrouping] Used to specify a custom grouping for the menu items in the annotation creation toolbar.
 * @property {Array<string>} [leftBarButtonItems] Sets the left bar button items. Note: The same button item cannot be added to both the left and right bar button items simultaneously. Deprecated since Nutrient React Native SDK 4.0. Use ```NutrientView.toolbar.leftBarButtonItems``` instead.
 * @property {Array<string>} [rightBarButtonItems] Sets the right bar button items. Note: The same button item cannot be added to both the left and right bar button items simultaneously. Deprecated since Nutrient React Native SDK 4.0. Use ```NutrientView.toolbar.rightBarButtonItems``` instead.
 * @property {string} [toolbarTitle] Used to specify a custom toolbar title on iOS by setting the ```title``` property of the ```PSPDFViewController```. Note: You need to set ```documentLabelEnabled```, ```useParentNavigationBar```, and ```allowToolbarTitleChange``` to ```false``` in your configuration before setting the custom title. Deprecated since Nutrient React Native SDK 4.0. Use ```toolbarTitle``` on the ```PDFConfiguration``` object instead.
 * @property {Array<string>} [toolbarMenuItems] Used to customize the toolbar menu items for Android. Deprecated since Nutrient React Native SDK 4.0. Use ```NutrientView.toolbar.toolbarMenuItems``` instead.
 * @property {boolean} [showNavigationButtonInToolbar] When set to ```true```, the toolbar integrated into the ```NutrientView``` will display a back button in the top-left corner. Android only.
 * @property {function} [onNavigationButtonClicked] If ```showNavigationButtonInToolbar``` is set to ```true```, this callback will notify you when the back button is tapped.
 * @property {Array<string>} [availableFontNames] Used to specify the available font names in the font picker. Note on iOS: You need to set the desired font family names as ```UIFontDescriptor```. See {@link https://developer.apple.com/documentation/uikit/uifontdescriptor?language=objc} for more information. See {@link https://github.com/PSPDFKit/react-native/blob/master/samples/Catalog/examples/CustomFontPicker.tsx}
 * @property {string} [selectedFontName] Used to specify the current selected font in the font picker. Note on iOS: You need to set the desired font family names as ```UIFontDescriptor```. See {@link https://developer.apple.com/documentation/uikit/uifontdescriptor?language=objc} for more information. See {@link https://github.com/PSPDFKit/react-native/blob/master/samples/Catalog/examples/CustomFontPicker.tsx}
 * @property {boolean} [showDownloadableFonts] Used to show or hide the downloadable fonts section in the font picker. Defaults to ```true```, showing the downloadable fonts. See {@link https://developer.apple.com/documentation/uikit/uifontdescriptor?language=objc} for more information. See {@link https://github.com/PSPDFKit/react-native/blob/master/samples/Catalog/examples/CustomFontPicker.tsx}
 * @property {AnnotationPresetConfiguration} [annotationPresets] The annotation preset configuration. See {@link https://nutrient.io/api/react-native/Annotation.html#.AnnotationPresetConfiguration} for available options.
 * @property {boolean} [hideDefaultToolbar] Used to show or hide the main toolbar on Android.
 * @property {any} [style] Used to style the React Native component.
 *
 * @extends {Component<Props>}
 */

NutrientView.propTypes = {
  /**
   * The path to the PDF file that should be displayed.
   * @type {string}
   * @memberof NutrientView
   */
  document: PropTypes.string.isRequired,
  /**
   * Configuration object to customize the appearance and behavior of Nutrient.
   * @type {PDFConfiguration}
   * @memberof NutrientView
   * @see {@link https://nutrient.io/api/react-native/PDFConfiguration.html} for available options.
   * Note: On iOS, set the ```useParentNavigationBar``` configuration option to ```true``` if you're using a navigation plugin such as
   * ```NavigatorIOS``` or ```react-native-navigation```. This is because the plugin will manage the navigation bar.
   */
  configuration: PropTypes.object,
  /**
   * Toolbar object to customize the toolbar appearance and behaviour.
   * @type {Toolbar}
   * @memberof NutrientView
   */
  toolbar: PropTypes.object,
  /**
   * Object to customize the menu shown when selecting an annotation.
   * @type {AnnotationContextualMenu}
   * @memberof NutrientView
   */
  annotationContextualMenu: PropTypes.object,
  /**
   * Object to customize the menu shown when selecting text.
   * @type {TextSelectionContextualMenu}
   * @memberof NutrientView
   */
  textSelectionContextualMenu: PropTypes.object,
  /**
   * Page index of the document that will be shown. Starts at 0.
   * @type {number}
   * @memberof NutrientView
   */
  pageIndex: PropTypes.number,
  /**
   * Controls whether a navigation bar is created and shown or not. Navigation bar is shown by default (```false```).
   * @type {boolean}
   * @memberof NutrientView
   */
  hideNavigationBar: PropTypes.bool,
  /**
   * Specifies whether the close button should be shown in the navigation bar. Disabled by default (```false```).
   * Only applies when the ```NutrientView``` is presented modally.
   * Will call ```onCloseButtonPressed``` when tapped if a callback was provided.
   * If ```onCloseButtonPressed``` wasn't provided, ```NutrientView``` will automatically be dismissed when modally presented.
   * @deprecated Since Nutrient React Native SDK 2.16. Use the ```toolbar``` property to add the ```Toolbar.DefaultToolbarButton.CLOSE_BUTTON_ITEM``` button item when setting up the ```NutrientView``` instead.
   * @type {boolean}
   * @memberof NutrientView
   */
  showCloseButton: PropTypes.bool,
  /**
   * Controls whether or not the default action for tapped annotations is processed. Defaults to processing the action (```false```).
   * Does not take precedence over the ```onShouldExecuteAction``` callback for annotation actions.
   * @type {boolean}
   * @memberof NutrientView
   */
  disableDefaultActionForTappedAnnotations: PropTypes.bool,
  /**
   * Controls whether or not the document will automatically be saved. Defaults to automatically saving (```false```).
   * @type {boolean}
   * @deprecated Since Nutrient React Native SDK 4.0. Use ```disableDocumentEditing``` on the ```PDFConfiguration``` object instead.
   * @memberof NutrientView
   */
  disableAutomaticSaving: PropTypes.bool,
  /**
   * Controls the author name that's set for new annotations.
   * If not set and the user hasn't specified it before, the user will be asked and the result will be saved.
   * The value set here will be persisted and the user won't be asked, even if this isn't set the next time.
   * @type {string}
   * @memberof NutrientView
   */
  annotationAuthorName: PropTypes.string,
  /**
   * Specifies what is written back to the original image URL when the receiver is saved.
   * If this property is ```flattenAndEmbed```, then this allows for changes made to the image to be saved as metadata in the original file.
   * If the same file is reopened, all previous changes made will remain editable.
   * If this property is ```flatten```, the changes are simply written to the image, and will not be editable when reopened.
   * Available options are: ```flatten``` or ```flattenAndEmbed```.
   * @type {string}
   * @memberof NutrientView
   */
  imageSaveMode: PropTypes.string,
  /**
   * Callback that's called when the user tapped the close button.
   * If you provide this function, you need to handle dismissal yourself.
   * If you don't provide this function, ```NutrientView``` will be automatically dismissed.
   * Only applies when the ```NutrientView``` is presented modally.
   * @type {function}
   * @memberof NutrientView
   * @example
   * onCloseButtonPressed={() => {
   *     // Optionally perform operations and close the modal window.
   * }}
   */
  onCloseButtonPressed: PropTypes.func,
  /**
   * Callback that's called when the document is loaded in the ```NutrientView```.
   * @type {function}
   * @memberof NutrientView
   * @deprecated Since Nutrient React Native SDK 4.0. Use ```NotificationCenter.DocumentEvent.LOADED``` instead.
   * @example
   * onDocumentLoaded={() => {
   *     // Document loaded event.
   * }}
   */
  onDocumentLoaded: PropTypes.func,
  /**
   * Callback that's called when the ```NutrientView``` is ready. Use this callback start interacting with the ```PDFDocument``` object. Does not indicate a successful document load - use ```NotificationCenter.DocumentEvent.LOADED``` to monitor this.
   * @type {function}
   * @memberof NutrientView
   */
  onReady: PropTypes.func,
  /**
   * Callback that's called when the document failed to load.
   * @type {function}
   * @memberof NutrientView
   * @deprecated Since Nutrient React Native SDK 4.0. Use ```NotificationCenter.DocumentEvent.LOAD_FAILED``` instead.
   * @example
   * onDocumentLoadFailed={() => {
   *     // Document load failed event.
   * }}
   */
  onDocumentLoadFailed: PropTypes.func,
  /**
   * Callback that's called when the document is saved.
   * @type {function}
   * @memberof NutrientView
   * @example
   * onDocumentSaved={() => {
   *     // Document saved event.
   * }}
   */
  onDocumentSaved: PropTypes.func,
  /**
   * Callback that's called when the document fails to save.
   * @returns { object } An object containing the error message.
   * @type {function}
   * @memberof NutrientView
   * @example
   * onDocumentSaveFailed={result => {
   *    alert('Document Save Failed: ' + JSON.stringify(result));
   *    // { error: "Error message" }
   * }}
   */
  onDocumentSaveFailed: PropTypes.func,
  /**
   * Callback that's called when an annotation is tapped. The result contains the InstantJSON of the annotation that was tapped.
   * @type {function}
   * @memberof NutrientView
   * @deprecated Since Nutrient React Native SDK 4.0. Use ```NotificationCenter.AnnotationsEvent.TAPPED``` or ```NotificationCenter.AnnotationsEvent.SELECTED``` instead.
   * @example
   * onAnnotationTapped={result => {
   *     if (result.error) {
   *         alert(result.error);
   *     } else {
   *         alert('Tapped on Annotation: ' + JSON.stringify(result));
   *     }
   * }}
   */
  onAnnotationTapped: PropTypes.func,
  /**
   * Callback that's called when an annotation is added, changed, or removed.
   * The result contains the type of change, as well as an array of the InstantJSON annotations.
   * @type {function}
   * @memberof NutrientView
   * @deprecated Since Nutrient React Native SDK 4.0. Use ```NotificationCenter.AnnotationsEvent.ADDED```, ```NotificationCenter.AnnotationsEvent.CHANGED```, or ```NotificationCenter.AnnotationsEvent.REMOVED``` instead.
   * @example
   * onAnnotationsChanged={result => {
   *     if (result.error) {
   *         alert(result.error);
   *     } else {
   *         alert('Annotations ' + result.change + ': ' + JSON.stringify(result.annotations));
   *     }
   *  }}
   */
  onAnnotationsChanged: PropTypes.func,
  /**
   * Callback that's called when the state of the ```NutrientView``` changes.
   * @type {function}
   * @memberof NutrientView
   * @example
   * onStateChanged={result => {
   *     if (result.error) {
   *         alert(result.error);
   *     } else {
   *         alert('Document State Changed: ' + JSON.stringify(result));
   *         // {"currentPageIndex":0,
   *         //  "textSelectionActive":false,
   *         //  "affectedPageIndex":0,
   *         //  "target":1013,
   *         //  "pageCount":21,
   *         //  "formEditingActive":false,
   *         //  "annotationCreationActive":false,
   *         //  "annotationEditingActive":false,
   *         //  "documentLoaded":true}
   *     }
   *  }}
   */
  onStateChanged: PropTypes.func,
  /**
   * Callback that's called when a custom toolbar button is tapped.
   * @type {function}
   * @memberof NutrientView
   * @example
   * onCustomToolbarButtonTapped={result => {
   *     if (result.error) {
   *         alert(result.error);
   *     } else {
   *         alert('Custom bar button item tapped: ' + JSON.stringify(result));
   *     }
   *  }}
   */
  onCustomToolbarButtonTapped: PropTypes.func,
  /**
   * Callback that's called when a custom annotation menu item is tapped.
   * @type {function}
   * @memberof NutrientView
   * @example
   * onCustomAnnotationContextualMenuItemTapped={result => {
   *     if (result.error) {
   *         alert(result.error);
   *     } else {
   *         alert('Custom annotation contextual menu item tapped: ' + JSON.stringify(result));
   *     }
   *  }}
   */
  onCustomAnnotationContextualMenuItemTapped: PropTypes.func,
  /**
   * Callback that's called when a custom text selection menu item is tapped.
   * @type {function}
   * @memberof NutrientView
   */
  onCustomTextSelectionContextualMenuItemTapped: PropTypes.func,
  /**
   * The tag used to identify a single ```PdfFragment``` in the view hierarchy.
   * This needs to be unique in the view hierarchy.
   * @type {string}
   * @memberof NutrientView
   */
  fragmentTag: PropTypes.string,
  /**
   * On iOS, you can specify a custom grouping for the annotation creation toolbar items.
   * @type {Array}
   * @memberof NutrientView
   * @see {@link https://github.com/PSPDFKit/react-native/blob/master/ios/Converters/RCTConvert+PSPDFAnnotationToolbarConfiguration.m} for the complete list of toolbar items.
   * @example
   * menuItemGrouping={[
   *   'pen',
   *   'freetext',
   *   { key: 'markup', items: ['highlight', 'underline'] },
   *   'image',
   * ]}
   */
  menuItemGrouping: PropTypes.array,
  /**
   * Sets the left bar button items.
   * Note: The same button item cannot be added to both the left and right bar button items simultaneously.
   * @type {Array<string>}
   * @memberof NutrientView
   * @see {@link https://github.com/PSPDFKit/react-native/blob/master/ios/Converters/RCTConvert+UIBarButtonItem.m} for supported button items.
   */
  leftBarButtonItems: PropTypes.array,
  /**
   * Sets the right bar button items.
   * Note: The same button item cannot be added to both the left and right bar button items simultaneously.
   * @type {Array<string>}
   * @memberof NutrientView
   * @see {@link https://github.com/PSPDFKit/react-native/blob/master/ios/Converters/RCTConvert+UIBarButtonItem.m} for supported button items.
   */
  rightBarButtonItems: PropTypes.array,
  /**
   * Used to specify a custom toolbar title on iOS by setting the ```title``` property of the ```PSPDFViewController```.
   * Note: You need to set ```documentLabelEnabled```, ```useParentNavigationBar```, and ```allowToolbarTitleChange``` to ```false``` in your configuration before setting the custom title.
   * @type {string}
   * @deprecated Since Nutrient React Native SDK 4.0. Use ```toolbarTitle``` on the ```PDFConfiguration``` object instead.
   * @memberof NutrientView
   */
  toolbarTitle: PropTypes.string,
  /**
   * Used to customize the toolbar menu items for Android.
   * @type {Array<string>}
   * @memberof NutrientView
   * @see {@link https://github.com/PSPDFKit/react-native/blob/master/android/src/main/java/com/pspdfkit/react/ToolbarMenuItemsAdapter.java} for supported toolbar menu items.
   */
  toolbarMenuItems: PropTypes.array,
  /**
   * When set to ```true```, the toolbar integrated into the ```NutrientView``` will display a back button in the top-left corner. Android only.
   * @type {boolean}
   * @memberof NutrientView
   */
  showNavigationButtonInToolbar: PropTypes.bool,
  /**
   * If ```showNavigationButtonInToolbar``` is set to ```true```, this callback will notify you when the back button is tapped.
   * @type {function}
   * @memberof NutrientView
   */
  onNavigationButtonClicked: PropTypes.func,
  /**
   * Used to specify the available font names in the font picker.
   * Note on iOS: You need to set the desired font family names as ```UIFontDescriptor```.
   * @type {Array<string>}
   * @memberof NutrientView
   * @see {@link https://developer.apple.com/documentation/uikit/uifontdescriptor?language=objc} for more information.
   * @see {@link https://github.com/PSPDFKit/react-native/blob/master/samples/Catalog/examples/CustomFontPicker.tsx}
   */
  availableFontNames: PropTypes.array,
  /**
   * Used to specify the current selected font in the font picker.
   * Note on iOS: You need to set the desired font family names as ```UIFontDescriptor```.
   * @type {string}
   * @memberof NutrientView
   * @see {@link https://developer.apple.com/documentation/uikit/uifontdescriptor?language=objc} for more information.
   * @see {@link https://github.com/PSPDFKit/react-native/blob/master/samples/Catalog/examples/CustomFontPicker.tsx}
   *
   * Note on Android: This is the default font that's selected. If the user changes the font, it'll become the new default.
   */
  selectedFontName: PropTypes.string,
  /**
   * Used to show or hide the downloadable fonts section in the font picker.
   * Defaults to ```true```, showing the downloadable fonts.
   * @type {boolean}
   * @memberof NutrientView
   * @see {@link https://github.com/PSPDFKit/react-native/blob/master/samples/Catalog/examples/CustomFontPicker.tsx}
   */
  showDownloadableFonts: PropTypes.bool,
  /**
   * Used to style the React Native component.
   * @type {any}
   * @memberof NutrientView
   */
  style: PropTypes.any,
  /**
   * The annotation preset configuration.
   * @type {AnnotationPresetConfiguration}
   * @memberof NutrientView
   * @see {@link https://nutrient.io/api/react-native/Annotation.html#.AnnotationPresetConfiguration} for available options.
   * @example
   * annotationPresets={{
   *   inkPen: {
   *     defaultThickness: 50,
   *     minimumThickness: 1,
   *     maximumThickness: 60,
   *     defaultColor: '#99cc00',
   *   },
   *   freeText: {
   *     defaultTextSize: 20,
   *     defaultColor: '#FF0000',
   *   },
   * }}
   */
  annotationPresets: PropTypes.object,
  /**
   * Used to show or hide the main toolbar on Android.
   * Defaults to ```true```, showing the toolbar.
   * @type {boolean}
   * @memberof NutrientView
   */
  hideDefaultToolbar: PropTypes.bool,
};

export default NutrientView;

/**
 * @typedef InstantDocumentData
 * @property { string } jwt The JWT received as part of the web response.
 * @property { string } serverUrl The server URL received as part of the web response.
 */

/**
 * @typedef InstantConfiguration
 * @property { boolean } enableInstantComments Specifies whether adding comment annotations is allowed.
 * @property { boolean } listenToServerChanges Automatically listen for and sync changes from the server.
 * @property { number } delay Delay in seconds before kicking off automatic sync after local changes are made to the ```editableDocument```'s annotations.
 * @property { boolean } syncAnnotations Specifies whether added annotations are automatically synced to the server.
 */

/**
 * @typedef PDFDocumentProperties
 * @property { string } documentId The document ID.
 * @property { number } pageCount The number of pages in the document.
 * @property { boolean } isEncrypted Indicates if the PDF document is encrypted (password protected).
 */

/**
 * Nutrient is a React Native {@link https://reactnative.dev/docs/native-modules-intro|Native Module} implementation used to call iOS and Android methods directly.
 * @hideconstructor
 * @example
 * const Nutrient = NativeModules.Nutrient;
 */
export class Nutrient {
  /**
   * Used to get the current version of the underlying Nutrient SDK.
   * @member versionString
   * @memberof Nutrient
   * @type { string }
   * @example
   * const version = Nutrient.versionString
   */
  versionString;

  /**
   * Used to get the document properties of the specified document.
   * @method getDocumentProperties
   * @memberof Nutrient
   * @param { string } documentPath The path to the document.
   * @returns { PDFDocumentProperties } The document properties.
   * @example
   * const properties = Nutrient.getDocumentProperties('path/to/document.pdf');
   */
  getDocumentProperties = function (documentPath) {};

  /**
   * Used to set your Nutrient license key for the active platform only, either iOS or Android.
   * Nutrient is commercial software.
   * Each Nutrient license is bound to a specific app bundle ID.
   * Visit {@link https://my.nutrient.io} to get your demo or commercial license key.
   * @method setLicenseKey
   * @memberof Nutrient
   * @param { string | null } [key] Your Nutrient for React Native iOS or Nutrient for React Native Android license key.
   * @returns { boolean } A boolean returning ```true``` if the license key was set, and ```false``` if not.
   * @example
   * Nutrient.setLicenseKey('YOUR_LICENSE_KEY');
   */
  setLicenseKey = function (key) {};

  /**
   * Used to set the your Nutrient license keys for both platforms.
   * Nutrient is commercial software.
   * Each Nutrient license is bound to a specific app bundle ID.
   * Visit {@link https://my.nutrient.io} to get your demo or commercial license key.
   * @method setLicenseKeys
   * @memberof Nutrient
   * @param { string | null } [androidKey] Your Nutrient for React Native Android license key.
   * @param { string | null } [iosKey] Your Nutrient for React Native iOS license key.
   * @returns { boolean } A boolean returning ```true``` if the license key was set, and ```false``` if not.
   * @example
   * Nutrient.setLicenseKeys('YOUR_ANDROID_LICENSE_KEY', 'YOUR_IOS_LICENSE_KEY');
   */
  setLicenseKeys = function (androidKey, iosKey) {};

  /**
   * Used to present a PDF document.
   * @method present
   * @memberof Nutrient
   * @param { string } documentPath The path to the PDF document to be presented.
   * @param { PDFConfiguration } configuration Configuration object to customize the appearance and behavior of Nutrient. See {@link https://nutrient.io/api/react-native/PDFConfiguration.html} for available options.
   * @returns { Promise<boolean> } A promise returning ```true``` if the document was successfully presented, and ```false``` if not.
   * @example
   * const fileName = 'document.pdf';
   * const exampleDocumentPath =
   * Platform.OS === 'ios' ? 'PDFs/' + fileName
   * : 'file:///android_asset/' + fileName;
   *
   * const configuration: PDFConfiguration = {
   *    pageMode: PDFConfiguration.PageMode.AUTOMATIC,
   *    scrollDirection: PDFConfiguration.ScrollDirection.HORIZONTAL,
   *    enableAnnotationEditing: PDFConfiguration.BooleanType.TRUE,
   *    pageTransition: PDFConfiguration.PageTransition.SCROLL_CONTINUOUS
   * };
   *
   * Nutrient.present(exampleDocumentPath, configuration);
   */
  present = function (documentPath, configuration) {};

  /**
   * Used to dismiss the ```NutrientView```.
   * @method dismiss
   * @memberof Nutrient
   * @returns { Promise<boolean> } A promise returning ```true``` if the view was successfully dismissed, and ```false``` if not.
   * @example
   * Nutrient.dismiss();
   */
  dismiss = function () {};

  /**
   * Used to set the current page of the document. Starts at 0.
   * @method setPageIndex
   * @memberof Nutrient
   * @param { number } pageIndex The page to transition to.
   * @param { boolean } animated ```true``` if the transition should be animated, and ```false``` otherwise.
   * @returns { Promise<boolean> } A promise returning ```true``` if the page was successfully set, and ```false``` if not.
   * @example
   * Nutrient.setPageIndex(3, false);
   */
  setPageIndex = function (pageIndex, animated) {};

  /**
   * Used to create a new document with processed annotations, allowing a password to unlock the source document.
   * @method processAnnotations
   * @memberof Nutrient
   * @param { Annotation.Change } annotationChange Specifies how an annotation should be included in the resulting document. See {@link https://nutrient.io/api/react-native/Annotation.html#.Change} for supported options.
   * @param { Array<Annotation.Type> } annotationTypes Specifies the annotation types that should be flattened. See {@link https://nutrient.io/api/react-native/Annotation.html#.Type} for supported types. Use ```Annotation.Type.ALL``` to include all annotation types.
   * @param { string } sourceDocumentPath The source document to use as input.
   * @param { string } processedDocumentPath The path where the output document should be written to.
   * @param { string | null } password The password to unlock the source document. Use ```null``` if not required.
   * @returns { Promise<boolean> } A promise returning ```true``` if the document annotations were successfully flattened, and ```false``` if not.
   * @example
   * const result = await Nutrient.processAnnotations(
   *                      'flatten',
   *                      'all',
   *                      sourceDocumentPath,
   *                      processedDocumentPath,
   *                      password);
   */
  processAnnotations = function (
    annotationChange,
    annotationTypes,
    sourceDocumentPath,
    processedDocumentPath,
    password,
  ) {};

  /**
   * Used to present an Instant PDF document for collaboration.
   * @method presentInstant
   * @memberof Nutrient
   * @param { InstantDocumentData } documentData The Instant document data received entirely from the web response.
   * @param { PDFConfiguration } configuration Configuration object to customize the appearance and behavior of Nutrient. See {@link https://nutrient.io/api/react-native/PDFConfiguration.html} for available options. Also see {@link InstantConfiguration} for additional Instant configuration options.
   * @returns { Promise<boolean> } A promise returning ```true``` if the document was successfully presented, and ```false``` if not.
   * @see {@link https://github.com/PSPDFKit/react-native/blob/5b2716a3f3cd3732c0e5845cc39e28d19b618aa4/samples/Catalog/examples/InstantSynchronization.js#L85C7-L85C7} for an example implementation.
   * @example
   * // Data received from your backend service.
   * const serverResult = await fetch('your-backend-server-url');
   * const documentData = {
   *     jwt: serverResult.jwt,
   *     serverUrl: Constants.InstantServerURL
   * };
   * const configuration: PDFConfiguration = {
   *    enableInstantComments: PDFConfiguration.BooleanType.FALSE,
   *    listenToServerChanges: PDFConfiguration.BooleanType.TRUE,
   *    delay: 1,
   *    syncAnnotations: PDFConfiguration.BooleanType.TRUE,
   * };
   *
   * Nutrient.presentInstant(documentData, configuration);
   */
  presentInstant = function (documentData, configuration) {};

  /**
   * Delay in seconds before kicking off automatic sync after local changes are made to the ```editableDocument```'s annotations.
   * @method setDelayForSyncingLocalChanges
   * @memberof Nutrient
   * @param { number } delay The delay in seconds.
   */
  setDelayForSyncingLocalChanges = function (delay) {};

  /**
   * Automatically listen for and sync changes from the server.
   * @method setListenToServerChanges
   * @memberof Nutrient
   * @param { boolean } listenToServerChanges ```true``` if server changes should be synced automatically, and false ```false``` otherwise.
   */
  setListenToServerChanges = function (listenToServerChanges) {};

  /**
   * Method used by React Native Native Modules
   * @ignore
   */
  addListener = function (eventName) {};

  /**
   * Method used by React Native Native Modules
   * @ignore
   */
  removeListeners = function () {};

  /**
   * Method used by React Native Native Modules
   * @ignore
   * @param { string } event The event name.
   * @param { number } componentId The component ID.
   * @returns { Promise<void> }
   */
  handleListenerAdded = function (event, componentId) {};

  /**
   * Method used by React Native Native Modules
   * @ignore
   * @param { string } event The event name.
   * @param { number } componentId The component ID.
   * @returns { Promise<void> }
   */
  handleListenerRemoved = function (event, componentId) {};
}

/**
 * @typedef BlankPDFConfiguration
 * @property { string } [name] The name of the new document.
 * @property { string } [filePath] The directory where the new document should be stored.
 * @property { number } width The width of the new document.
 * @property { number } height The height of the new document.
 * @property { boolean } override If ```true```, will override existing document with the same name.
 */

/**
 * @typedef PDFTemplatePageSize
 * @property { number } width The width of the page.
 * @property { number } height The height of the page.
 */

/**
 * @typedef PDFTemplatePageMargins
 * @property { number } top The top margin.
 * @property { number } left The left margin.
 * @property { number } right The right margin.
 * @property { number } bottom The bottom margin.
 */

/**
 * @typedef PDFTemplate
 * @property { PDFTemplatePageSize } pageSize The size of the page.
 * @property { string } [backgroundColor] The background color of the page. Can be either a rgba string, for example: rgba(0.871, 0.188, 0.643, 0.5), or standard colors such as ```blue``` or ```yellow```.
 * @property { string } [template] Which template to use. Options are: ```blank```, ```dot5mm```, ```grid5mm```, ```lines5mm``` and ```lines7mm```.
 * @property { number } [rotation] The page rotation, in degrees.
 * @property { PDFTemplatePageMargins } [pageMargins] The page margins.
 */

/**
 * @typedef TemplatePDFConfiguration
 * @property { string } [name] The name of the new document.
 * @property { string } [filePath] The directory where the new document should be stored.
 * @property { Array<PDFTemplate> } templates An array of the templates that should be used to construct the new document.
 * @property { boolean } override If ```true```, will override existing document with the same name.
 */

/**
 * @typedef PDFImage
 * @property { string } imageUri The URI to the image file.
 * @property { string } [position] The image position on the PDF page. Options are: ```top```, ```bottom```, ```left```, ```right```, ```center```.
 * @property { number } [rotation] The page rotation, in degrees.
 * @property { PDFTemplatePageMargins } [pageMargins] The page margins.
 * @property { PDFTemplatePageSize } [pageSize] The size of the page.
 */

/**
 * @typedef ImagePDFConfiguration
 * @property { string } [name] The name of the new document.
 * @property { string } [filePath] The directory where the new document should be stored.
 * @property { Array<PDFImage> } images An array of the images that should be used to construct the new document.
 * @property { boolean } override If ```true```, will override existing document with the same name.
 */

/**
 * @typedef PDFDocumentConfiguration
 * @property { string } documentPath The URI to the existing document.
 * @property { number } [pageIndex] The index of the page that should be used from the document. Starts at 0. If not specified, the entire document will be used.
 */

/**
 * @typedef DocumentPDFConfiguration
 * @property { string } [name] The name of the new document.
 * @property { string } [filePath] The directory where the new document should be stored.
 * @property { Array<PDFDocumentConfiguration> } documents An array of the documents that should be used to construct the new document.
 * @property { boolean } override If ```true```, will override existing document with the same name.
 */

/**
 * @typedef GeneratePDFConfiguration
 * @property { string } [name] The name of the new document.
 * @property { string } [filePath] The directory where the new document should be stored.
 * @property { boolean } override If ```true```, will override existing document with the same name.
 */

/**
 * @typedef GeneratePDFResult
 * @property { string } fileURL The path on the filesystem where the new document is stored.
 */

/**
 * Processor is a React Native {@link https://reactnative.dev/docs/native-modules-intro|Native Module} implementation used to call iOS and Android methods directly.
 * @hideconstructor
 * @example
 * const Processor = NativeModules.RNProcessor;
 */
export class Processor {
  /**
   * Used to generate a new blank PDF document.
   * @method generateBlankPDF
   * @memberof Processor
   * @param { BlankPDFConfiguration } configuration The configuration to generate a new blank PDF document.
   * @returns { Promise<GeneratePDFResult> } A promise containing the path to the newly generated document.
   * @example
   * const configuration = {
   *    name: 'newDocument.pdf',
   *    width: 595,
   *    height: 842,
   *    override: true,
   *  };
   * const { fileURL } = await Processor.generateBlankPDF(configuration);
   */
  generateBlankPDF = function (configuration) {};

  /**
   * Used to generate a new PDF document from an HTML string.
   * @method generatePDFFromHtmlString
   * @memberof Processor
   * @param { GeneratePDFConfiguration } configuration The configuration to generate a new PDF document.
   * @param { string } html The HTML string from which the document should be generated.
   * @returns { Promise<GeneratePDFResult> } A promise containing the path to the newly generated document.
   * @example
   * const fileName = 'newDocument.pdf';
   * const { tempDir } = await Processor.getTemporaryDirectory();
   * const documentPath = `${tempDir}/${fileName}`;
   *
   * const htmlString = `<html lang="en"><head></head><body><h1>PDF generated from HTML</h1></body></html>`;
   * const configuration = {
   *    filePath: documentPath,
   *    override: true,
   *  };
   * const { fileURL } = await Processor.generatePDFFromHtmlString(configuration, htmlString);
   */
  generatePDFFromHtmlString = function (configuration, html) {};

  /**
   * Used to generate a new PDF document from an HTML URL.
   * @method generatePDFFromHtmlURL
   * @memberof Processor
   * @param { GeneratePDFConfiguration } configuration The configuration to generate a new PDF document.
   * @param { string } url The origin URL from which the document should be generated.
   * @returns { Promise<GeneratePDFResult> } A promise containing the path to the newly generated document.
   * @example
   * const fileName = 'newDocument.pdf';
   * const { tempDir } = await Processor.getTemporaryDirectory();
   * const documentPath = `${tempDir}/${fileName}`;

   * const url = `https://www.nutrient.io`;
   * const configuration = {
   *    documentPath: documentPath,
   *    override: true,
   *  };
   * const { fileURL } = await Processor.generatePDFFromHtmlURL(configuration, url);
   */
  generatePDFFromHtmlURL = function (configuration, url) {};

  /**
   * Used to generate a new PDF document from a template.
   * @method generatePDFFromTemplate
   * @memberof Processor
   * @param { TemplatePDFConfiguration } configuration The configuration to generate a new PDF document.
   * @returns { Promise<GeneratePDFResult> } A promise containing the path to the newly generated document.
   * @example
   * const configuration = {
   *    filePath: fileURL,
   *    override: true,
   *     templates: [
   *       {
   *         pageSize: { width: 540, height: 846 },
   *         backgroundColor: 'rgba(0.871, 0.188, 0.643, 0.5)',
   *         template: 'lines7mm',
   *         rotation: 90,
   *         pageMargins: { top: 10, left: 10, right: 10, bottom: 10 },
   *       },
   *       {
   *         pageSize: { width: 540, height: 846 },
   *         backgroundColor: 'yellow',
   *         template: 'dot5mm',
   *       },
   *     ],
   *   };
   * const { fileURL } = await Processor.generatePDFFromTemplate(configuration);
   */
  generatePDFFromTemplate = function (configuration) {};

  /**
   * Used to generate a new PDF document from images.
   * @method generatePDFFromImages
   * @memberof Processor
   * @param { ImagePDFConfiguration } configuration The configuration to generate a new PDF document.
   * @returns { Promise<GeneratePDFResult> } A promise containing the path to the newly generated document.
   * @example
   * export const exampleImage = 'PSPDFKit_Image_Example.jpg';
   * export const exampleImagePath =
   * Platform.OS === 'ios' ? 'PDFs/' + exampleImage : 'file:///android_asset/' + exampleImage;
   *
   * // Helper method to get iOS bundlePath
   * let globalPath = getMainBundlePath(exampleImagePath.toString());
   * const configuration = {
   *     name: 'newDocument.pdf',
   *     images: [
   *       {
   *         imageUri: Platform.OS === 'ios' ? globalPath : exampleImagePath,
   *         position: 'center',
   *       },
   *     ],
   *     override: true,
   *   };
   * const { fileURL } = await Processor.generatePDFFromImages(configuration);
   */
  generatePDFFromImages = function (configuration) {};

  /**
   * Used to generate a new PDF document from existing PDF documents.
   * @method generatePDFFromDocuments
   * @memberof Processor
   * @param { DocumentPDFConfiguration } configuration The configuration to generate a new PDF document.
   * @returns { Promise<GeneratePDFResult> } A promise containing the path to the newly generated document.
   * @example
   * const fileName = 'newDocument.pdf';
   * const { tempDir } = await Processor.getTemporaryDirectory();
   * const documentPath = `${tempDir}/${fileName}`;
   *
   * const exampleDocument = 'PSPDFKit_Image_Example.jpg';
   * const exampleDocumentPath =
   * Platform.OS === 'ios' ? 'PDFs/' + exampleImage : 'file:///android_asset/' + exampleDocument;
   *
   * // Helper method to get iOS bundlePath
   * let globalPath = getMainBundlePath(exampleDocumentPath.toString());
   *
   * const configuration = {
   *     filePath: documentPath,
   *     name: fileName,
   *     documents: [
   *       {
   *         documentPath:
   *           Platform.OS === 'ios' ? globalPath : exampleDocumentPath,
   *         pageIndex: 5,
   *       },
   *       {
   *         documentPath:
   *           Platform.OS === 'ios' ? globalPath : exampleDocumentPath,
   *         pageIndex: 8,
   *       },
   *     ],
   *     override: true,
   *   };
   * const { fileURL } = await Processor.generatePDFFromDocuments(configuration);
   */
  generatePDFFromDocuments = function (configuration) {};

  /**
   * A helper method to get a temporary directory where the document can be written to.
   * @method getTemporaryDirectory
   * @memberof Processor
   * @returns { Promise<any> } A promise containing the path to the temporary directory that can be used for output.
   * @example
   * const { fileURL } = await Processor.getTemporaryDirectory();
   */
  getTemporaryDirectory = function () {};
}

import { PDFConfiguration } from './lib/configuration/PDFConfiguration';
export { PDFConfiguration } from './lib/configuration/PDFConfiguration';

import { AIAssistantConfiguration } from './lib/configuration/AIAssistantConfiguration';
export { AIAssistantConfiguration } from './lib/configuration/AIAssistantConfiguration';

import { RemoteDocumentConfiguration } from './lib/configuration/PDFConfiguration';
export { RemoteDocumentConfiguration } from './lib/configuration/PDFConfiguration';

import { Toolbar } from './lib/toolbar/Toolbar';
export { Toolbar } from './lib/toolbar/Toolbar';

import { Measurements } from './lib/measurements/Measurements';
export { Measurements } from './lib/measurements/Measurements';

import { MeasurementScale } from './lib/measurements/Measurements';
export { MeasurementScale } from './lib/measurements/Measurements';

import { MeasurementValueConfiguration } from './lib/measurements/Measurements';
export { MeasurementValueConfiguration } from './lib/measurements/Measurements';

import { Annotation } from './lib/annotations/Annotation';
export { Annotation } from './lib/annotations/Annotation';

import { AnnotationContextualMenu } from './lib/annotations/Annotation';
export { AnnotationContextualMenu } from './lib/annotations/Annotation';

import { AnnotationContextualMenuItem } from './lib/annotations/Annotation';
export { AnnotationContextualMenuItem } from './lib/annotations/Annotation';

import { AnnotationPresetConfiguration } from './lib/annotations/Annotation';
export { AnnotationPresetConfiguration } from './lib/annotations/Annotation';

import {
  AnnotationPresetEraser,
  AnnotationPresetFile,
  AnnotationPresetFreeText,
  AnnotationPresetInk,
  AnnotationPresetLine,
  AnnotationPresetMarkup,
  AnnotationPresetMeasurementArea,
  AnnotationPresetMeasurementDistance,
  AnnotationPresetMeasurementPerimeter,
  AnnotationPresetNote,
  AnnotationPresetRedact,
  AnnotationPresetShape,
  AnnotationPresetSound,
  AnnotationPresetStamp,
} from './lib/annotations/Annotation';
export {
  AnnotationPresetInk,
  AnnotationPresetFreeText,
  AnnotationPresetStamp,
  AnnotationPresetNote,
  AnnotationPresetMarkup,
  AnnotationPresetShape,
  AnnotationPresetLine,
  AnnotationPresetEraser,
  AnnotationPresetFile,
  AnnotationPresetSound,
  AnnotationPresetRedact,
  AnnotationPresetMeasurementArea,
  AnnotationPresetMeasurementPerimeter,
  AnnotationPresetMeasurementDistance,
} from './lib/annotations/Annotation';

import { PDFDocument } from './lib/document/PDFDocument';
export { PDFDocument } from './lib/document/PDFDocument';

import { PDFPageInfo } from './lib/document/PDFPageInfo';
export { PDFPageInfo } from './lib/document/PDFPageInfo';

import { Bookmark } from './lib/document/Bookmark';
export { Bookmark } from './lib/document/Bookmark';

import { NotificationCenter } from './lib/notification-center/NotificationCenter';
export { NotificationCenter } from './lib/notification-center/NotificationCenter';

import {
  NutrientOverlay,
  NutrientOverlayItem,
} from './lib/overlay/NutrientOverlay';
export {
  NutrientOverlay,
  NutrientOverlayItem,
} from './lib/overlay/NutrientOverlay';
export {
  NutrientOverlayProps,
  NutrientOverlayItemProps,
  NutrientOverlayPoint,
  NutrientOverlayViewRef,
} from './lib/overlay/NutrientOverlay';

import {
  AnnotationType,
  DocumentJSON,
  AnnotationAttachment,
  BaseAnnotation,
  CommentMarkerAnnotation,
  EllipseShapeAnnotation,
  HighlightMarkupAnnotation,
  ImageAnnotation,
  InkAnnotation,
  LineShapeAnnotation,
  LinkAnnotation,
  MarkupAnnotation,
  MediaAnnotation,
  NoteAnnotation,
  PolygonShapeAnnotation,
  PolylineShapeAnnotation,
  RectangleShapeAnnotation,
  RedactionMarkupAnnotation,
  ShapeAnnotation,
  SquigglyMarkupAnnotation,
  StampAnnotation,
  StrikeOutMarkupAnnotation,
  TextAnnotation,
  UnderlineMarkupAnnotation,
  WidgetAnnotation,
} from './lib/annotations/AnnotationModels';
export {
  AnnotationType,
  DocumentJSON,
  AnnotationAttachment,
  BaseAnnotation,
  CommentMarkerAnnotation,
  EllipseShapeAnnotation,
  HighlightMarkupAnnotation,
  ImageAnnotation,
  InkAnnotation,
  LineShapeAnnotation,
  LinkAnnotation,
  MarkupAnnotation,
  MediaAnnotation,
  NoteAnnotation,
  PolygonShapeAnnotation,
  PolylineShapeAnnotation,
  RectangleShapeAnnotation,
  RedactionMarkupAnnotation,
  ShapeAnnotation,
  SquigglyMarkupAnnotation,
  StampAnnotation,
  StrikeOutMarkupAnnotation,
  TextAnnotation,
  UnderlineMarkupAnnotation,
  WidgetAnnotation,
} from './lib/annotations/AnnotationModels';

import {
  FormField,
  ButtonFormField,
  ChoiceFormField,
  SignatureFormField,
  TextFormField,
} from './lib/forms/FormField';
export {
  FormField,
  ButtonFormField,
  ChoiceFormField,
  SignatureFormField,
  TextFormField,
} from './lib/forms/FormField';

import {
  FormElement,
  ButtonFormElement,
  ChoiceFormElement,
  SignatureFormElement,
  TextFieldFormElement,
} from './lib/forms/FormElement';
export {
  FormElement,
  ButtonFormElement,
  ChoiceFormElement,
  SignatureFormElement,
  TextFieldFormElement,
} from './lib/forms/FormElement';

import { Forms } from './lib/forms/Forms';
export { Forms } from './lib/forms/Forms';

module.exports.PDFDocument = PDFDocument;
module.exports.PDFPageInfo = PDFPageInfo;
module.exports.Bookmark = Bookmark;

module.exports.PDFConfiguration = PDFConfiguration;
module.exports.AIAssistantConfiguration = AIAssistantConfiguration;
module.exports.RemoteDocumentConfiguration = RemoteDocumentConfiguration;
module.exports.Toolbar = Toolbar;
module.exports.Measurements = Measurements;
module.exports.MeasurementScale = MeasurementScale;
module.exports.MeasurementValueConfiguration = MeasurementValueConfiguration;
module.exports.Annotation = Annotation;
module.exports.AnnotationContextualMenu = AnnotationContextualMenu;
module.exports.AnnotationContextualMenuItem = AnnotationContextualMenuItem;
module.exports.AnnotationPresetConfiguration = AnnotationPresetConfiguration;

module.exports.AnnotationPresetInk = AnnotationPresetInk;
module.exports.AnnotationPresetFreeText = AnnotationPresetFreeText;
module.exports.AnnotationPresetStamp = AnnotationPresetStamp;
module.exports.AnnotationPresetNote = AnnotationPresetNote;
module.exports.AnnotationPresetMarkup = AnnotationPresetMarkup;
module.exports.AnnotationPresetShape = AnnotationPresetShape;
module.exports.AnnotationPresetLine = AnnotationPresetLine;
module.exports.AnnotationPresetEraser = AnnotationPresetEraser;
module.exports.AnnotationPresetFile = AnnotationPresetFile;
module.exports.AnnotationPresetSound = AnnotationPresetSound;
module.exports.AnnotationPresetRedact = AnnotationPresetRedact;
module.exports.AnnotationPresetMeasurementArea =
  AnnotationPresetMeasurementArea;
module.exports.AnnotationPresetMeasurementPerimeter =
  AnnotationPresetMeasurementPerimeter;
module.exports.AnnotationPresetMeasurementDistance =
  AnnotationPresetMeasurementDistance;

module.exports.NotificationCenter = NotificationCenter;

module.exports.AnnotationType = AnnotationType;
module.exports.DocumentJSON = DocumentJSON;
module.exports.AnnotationAttachment = AnnotationAttachment;
module.exports.BaseAnnotation = BaseAnnotation;
module.exports.CommentMarkerAnnotation = CommentMarkerAnnotation;
module.exports.EllipseShapeAnnotation = EllipseShapeAnnotation;
module.exports.HighlightMarkupAnnotation = HighlightMarkupAnnotation;
module.exports.ImageAnnotation = ImageAnnotation;
module.exports.InkAnnotation = InkAnnotation;
module.exports.LineShapeAnnotation = LineShapeAnnotation;
module.exports.LinkAnnotation = LinkAnnotation;
module.exports.MarkupAnnotation = MarkupAnnotation;
module.exports.MediaAnnotation = MediaAnnotation;
module.exports.NoteAnnotation = NoteAnnotation;
module.exports.PolygonShapeAnnotation = PolygonShapeAnnotation;
module.exports.PolylineShapeAnnotation = PolylineShapeAnnotation;
module.exports.RectangleShapeAnnotation = RectangleShapeAnnotation;
module.exports.RedactionMarkupAnnotation = RedactionMarkupAnnotation;
module.exports.ShapeAnnotation = ShapeAnnotation;
module.exports.SquigglyMarkupAnnotation = SquigglyMarkupAnnotation;
module.exports.StampAnnotation = StampAnnotation;
module.exports.StrikeOutMarkupAnnotation = StrikeOutMarkupAnnotation;
module.exports.TextAnnotation = TextAnnotation;
module.exports.UnderlineMarkupAnnotation = UnderlineMarkupAnnotation;
module.exports.WidgetAnnotation = WidgetAnnotation;

module.exports.FormField = FormField;
module.exports.ButtonFormField = ButtonFormField;
module.exports.ChoiceFormField = ChoiceFormField;
module.exports.SignatureFormField = SignatureFormField;
module.exports.TextFormField = TextFormField;

module.exports.FormElement = FormElement;
module.exports.ButtonFormElement = ButtonFormElement;
module.exports.ChoiceFormElement = ChoiceFormElement;
module.exports.SignatureFormElement = SignatureFormElement;
module.exports.TextFieldFormElement = TextFieldFormElement;

module.exports.Forms = Forms;

module.exports.NutrientInstantView = NutrientInstantView;

// `module.exports = NutrientView` above replaces the exports object, discarding
// the ESM re-export bindings, so every public name has to be re-attached here.
module.exports.NutrientOverlay = NutrientOverlay;
module.exports.NutrientOverlayItem = NutrientOverlayItem;

// Type-only helper for onShouldExecuteAction; runtime value is unused.
module.exports.ShouldExecuteActionEvent = {};

// Type-only helper for onShouldShowSignaturePad; runtime value is unused.
module.exports.ShouldShowSignaturePadEvent = {};