@thatkid02/react-native-pdf-viewer 0.0.1

package/nitrogen/generated/ios/c++/HybridPdfViewerSpecSwift.hpp

@@ -0,0 +1,205 @@
+///
+/// HybridPdfViewerSpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridPdfViewerSpec.hpp"
+
+// Forward declaration of `HybridPdfViewerSpec_cxx` to properly resolve imports.
+namespace PdfViewer { class HybridPdfViewerSpec_cxx; }
+
+// Forward declaration of `LoadCompleteEvent` to properly resolve imports.
+namespace margelo::nitro::pdfviewer { struct LoadCompleteEvent; }
+// Forward declaration of `PageChangeEvent` to properly resolve imports.
+namespace margelo::nitro::pdfviewer { struct PageChangeEvent; }
+// Forward declaration of `ScaleChangeEvent` to properly resolve imports.
+namespace margelo::nitro::pdfviewer { struct ScaleChangeEvent; }
+// Forward declaration of `ErrorEvent` to properly resolve imports.
+namespace margelo::nitro::pdfviewer { struct ErrorEvent; }
+// Forward declaration of `ThumbnailGeneratedEvent` to properly resolve imports.
+namespace margelo::nitro::pdfviewer { struct ThumbnailGeneratedEvent; }
+// Forward declaration of `LoadingChangeEvent` to properly resolve imports.
+namespace margelo::nitro::pdfviewer { struct LoadingChangeEvent; }
+
+#include <string>
+#include <optional>
+#include "LoadCompleteEvent.hpp"
+#include <functional>
+#include "PageChangeEvent.hpp"
+#include "ScaleChangeEvent.hpp"
+#include "ErrorEvent.hpp"
+#include "ThumbnailGeneratedEvent.hpp"
+#include "LoadingChangeEvent.hpp"
+
+#include "PdfViewer-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::pdfviewer {
+
+  /**
+   * The C++ part of HybridPdfViewerSpec_cxx.swift.
+   *
+   * HybridPdfViewerSpecSwift (C++) accesses HybridPdfViewerSpec_cxx (Swift), and might
+   * contain some additional bridging code for C++ <> Swift interop.
+   *
+   * Since this obviously introduces an overhead, I hope at some point in
+   * the future, HybridPdfViewerSpec_cxx can directly inherit from the C++ class HybridPdfViewerSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridPdfViewerSpecSwift: public virtual HybridPdfViewerSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridPdfViewerSpecSwift(const PdfViewer::HybridPdfViewerSpec_cxx& swiftPart):
+      HybridObject(HybridPdfViewerSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline PdfViewer::HybridPdfViewerSpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+
+  public:
+    // Properties
+    inline std::optional<std::string> getSource() noexcept override {
+      auto __result = _swiftPart.getSource();
+      return __result;
+    }
+    inline void setSource(const std::optional<std::string>& source) noexcept override {
+      _swiftPart.setSource(source);
+    }
+    inline std::optional<bool> getHorizontal() noexcept override {
+      auto __result = _swiftPart.getHorizontal();
+      return __result;
+    }
+    inline void setHorizontal(std::optional<bool> horizontal) noexcept override {
+      _swiftPart.setHorizontal(horizontal);
+    }
+    inline std::optional<bool> getEnablePaging() noexcept override {
+      auto __result = _swiftPart.getEnablePaging();
+      return __result;
+    }
+    inline void setEnablePaging(std::optional<bool> enablePaging) noexcept override {
+      _swiftPart.setEnablePaging(enablePaging);
+    }
+    inline std::optional<double> getSpacing() noexcept override {
+      auto __result = _swiftPart.getSpacing();
+      return __result;
+    }
+    inline void setSpacing(std::optional<double> spacing) noexcept override {
+      _swiftPart.setSpacing(spacing);
+    }
+    inline std::optional<bool> getEnableZoom() noexcept override {
+      auto __result = _swiftPart.getEnableZoom();
+      return __result;
+    }
+    inline void setEnableZoom(std::optional<bool> enableZoom) noexcept override {
+      _swiftPart.setEnableZoom(enableZoom);
+    }
+    inline std::optional<double> getMinScale() noexcept override {
+      auto __result = _swiftPart.getMinScale();
+      return __result;
+    }
+    inline void setMinScale(std::optional<double> minScale) noexcept override {
+      _swiftPart.setMinScale(minScale);
+    }
+    inline std::optional<double> getMaxScale() noexcept override {
+      auto __result = _swiftPart.getMaxScale();
+      return __result;
+    }
+    inline void setMaxScale(std::optional<double> maxScale) noexcept override {
+      _swiftPart.setMaxScale(maxScale);
+    }
+    inline std::optional<bool> getShowsActivityIndicator() noexcept override {
+      auto __result = _swiftPart.getShowsActivityIndicator();
+      return __result;
+    }
+    inline void setShowsActivityIndicator(std::optional<bool> showsActivityIndicator) noexcept override {
+      _swiftPart.setShowsActivityIndicator(showsActivityIndicator);
+    }
+    inline std::optional<std::function<void(const LoadCompleteEvent& /* event */)>> getOnLoadComplete() noexcept override {
+      auto __result = _swiftPart.getOnLoadComplete();
+      return __result;
+    }
+    inline void setOnLoadComplete(const std::optional<std::function<void(const LoadCompleteEvent& /* event */)>>& onLoadComplete) noexcept override {
+      _swiftPart.setOnLoadComplete(onLoadComplete);
+    }
+    inline std::optional<std::function<void(const PageChangeEvent& /* event */)>> getOnPageChange() noexcept override {
+      auto __result = _swiftPart.getOnPageChange();
+      return __result;
+    }
+    inline void setOnPageChange(const std::optional<std::function<void(const PageChangeEvent& /* event */)>>& onPageChange) noexcept override {
+      _swiftPart.setOnPageChange(onPageChange);
+    }
+    inline std::optional<std::function<void(const ScaleChangeEvent& /* event */)>> getOnScaleChange() noexcept override {
+      auto __result = _swiftPart.getOnScaleChange();
+      return __result;
+    }
+    inline void setOnScaleChange(const std::optional<std::function<void(const ScaleChangeEvent& /* event */)>>& onScaleChange) noexcept override {
+      _swiftPart.setOnScaleChange(onScaleChange);
+    }
+    inline std::optional<std::function<void(const ErrorEvent& /* event */)>> getOnError() noexcept override {
+      auto __result = _swiftPart.getOnError();
+      return __result;
+    }
+    inline void setOnError(const std::optional<std::function<void(const ErrorEvent& /* event */)>>& onError) noexcept override {
+      _swiftPart.setOnError(onError);
+    }
+    inline std::optional<std::function<void(const ThumbnailGeneratedEvent& /* event */)>> getOnThumbnailGenerated() noexcept override {
+      auto __result = _swiftPart.getOnThumbnailGenerated();
+      return __result;
+    }
+    inline void setOnThumbnailGenerated(const std::optional<std::function<void(const ThumbnailGeneratedEvent& /* event */)>>& onThumbnailGenerated) noexcept override {
+      _swiftPart.setOnThumbnailGenerated(onThumbnailGenerated);
+    }
+    inline std::optional<std::function<void(const LoadingChangeEvent& /* event */)>> getOnLoadingChange() noexcept override {
+      auto __result = _swiftPart.getOnLoadingChange();
+      return __result;
+    }
+    inline void setOnLoadingChange(const std::optional<std::function<void(const LoadingChangeEvent& /* event */)>>& onLoadingChange) noexcept override {
+      _swiftPart.setOnLoadingChange(onLoadingChange);
+    }
+
+  public:
+    // Methods
+    inline void goToPage(double page) override {
+      auto __result = _swiftPart.goToPage(std::forward<decltype(page)>(page));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void setScale(double scale) override {
+      auto __result = _swiftPart.setScale(std::forward<decltype(scale)>(scale));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void generateThumbnail(double page) override {
+      auto __result = _swiftPart.generateThumbnail(std::forward<decltype(page)>(page));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void generateAllThumbnails() override {
+      auto __result = _swiftPart.generateAllThumbnails();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+
+  private:
+    PdfViewer::HybridPdfViewerSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::pdfviewer

package/nitrogen/generated/ios/c++/views/HybridPdfViewerComponent.mm

@@ -0,0 +1,161 @@
+///
+/// HybridPdfViewerComponent.mm
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#import "HybridPdfViewerComponent.hpp"
+#import <memory>
+#import <react/renderer/componentregistry/ComponentDescriptorProvider.h>
+#import <React/RCTViewComponentView.h>
+#import <React/RCTComponentViewFactory.h>
+#import <React/UIView+ComponentViewProtocol.h>
+#import <NitroModules/NitroDefines.hpp>
+#import <UIKit/UIKit.h>
+
+#import "HybridPdfViewerSpecSwift.hpp"
+#import "PdfViewer-Swift-Cxx-Umbrella.hpp"
+
+using namespace facebook;
+using namespace margelo::nitro::pdfviewer;
+using namespace margelo::nitro::pdfviewer::views;
+
+/**
+ * Represents the React Native View holder for the Nitro "PdfViewer" HybridView.
+ */
+@interface HybridPdfViewerComponent: RCTViewComponentView
+@end
+
+@implementation HybridPdfViewerComponent {
+  std::shared_ptr<HybridPdfViewerSpecSwift> _hybridView;
+}
+
++ (void) load {
+  [super load];
+  [RCTComponentViewFactory.currentComponentViewFactory registerComponentViewClass:[HybridPdfViewerComponent class]];
+}
+
++ (react::ComponentDescriptorProvider) componentDescriptorProvider {
+  return react::concreteComponentDescriptorProvider<HybridPdfViewerComponentDescriptor>();
+}
+
+- (instancetype) init {
+  if (self = [super init]) {
+    std::shared_ptr<HybridPdfViewerSpec> hybridView = PdfViewer::PdfViewerAutolinking::createPdfViewer();
+    _hybridView = std::dynamic_pointer_cast<HybridPdfViewerSpecSwift>(hybridView);
+    [self updateView];
+  }
+  return self;
+}
+
+- (void) updateView {
+  // 1. Get Swift part
+  PdfViewer::HybridPdfViewerSpec_cxx& swiftPart = _hybridView->getSwiftPart();
+
+  // 2. Get UIView*
+  void* viewUnsafe = swiftPart.getView();
+  UIView* view = (__bridge_transfer UIView*) viewUnsafe;
+
+  // 3. Update RCTViewComponentView's [contentView]
+  [self setContentView:view];
+}
+
+- (void) updateProps:(const std::shared_ptr<const react::Props>&)props
+            oldProps:(const std::shared_ptr<const react::Props>&)oldProps {
+  // 1. Downcast props
+  const auto& newViewPropsConst = *std::static_pointer_cast<HybridPdfViewerProps const>(props);
+  auto& newViewProps = const_cast<HybridPdfViewerProps&>(newViewPropsConst);
+  PdfViewer::HybridPdfViewerSpec_cxx& swiftPart = _hybridView->getSwiftPart();
+
+  // 2. Update each prop individually
+  swiftPart.beforeUpdate();
+
+  // source: optional
+  if (newViewProps.source.isDirty) {
+    swiftPart.setSource(newViewProps.source.value);
+    newViewProps.source.isDirty = false;
+  }
+  // horizontal: optional
+  if (newViewProps.horizontal.isDirty) {
+    swiftPart.setHorizontal(newViewProps.horizontal.value);
+    newViewProps.horizontal.isDirty = false;
+  }
+  // enablePaging: optional
+  if (newViewProps.enablePaging.isDirty) {
+    swiftPart.setEnablePaging(newViewProps.enablePaging.value);
+    newViewProps.enablePaging.isDirty = false;
+  }
+  // spacing: optional
+  if (newViewProps.spacing.isDirty) {
+    swiftPart.setSpacing(newViewProps.spacing.value);
+    newViewProps.spacing.isDirty = false;
+  }
+  // enableZoom: optional
+  if (newViewProps.enableZoom.isDirty) {
+    swiftPart.setEnableZoom(newViewProps.enableZoom.value);
+    newViewProps.enableZoom.isDirty = false;
+  }
+  // minScale: optional
+  if (newViewProps.minScale.isDirty) {
+    swiftPart.setMinScale(newViewProps.minScale.value);
+    newViewProps.minScale.isDirty = false;
+  }
+  // maxScale: optional
+  if (newViewProps.maxScale.isDirty) {
+    swiftPart.setMaxScale(newViewProps.maxScale.value);
+    newViewProps.maxScale.isDirty = false;
+  }
+  // showsActivityIndicator: optional
+  if (newViewProps.showsActivityIndicator.isDirty) {
+    swiftPart.setShowsActivityIndicator(newViewProps.showsActivityIndicator.value);
+    newViewProps.showsActivityIndicator.isDirty = false;
+  }
+  // onLoadComplete: optional
+  if (newViewProps.onLoadComplete.isDirty) {
+    swiftPart.setOnLoadComplete(newViewProps.onLoadComplete.value);
+    newViewProps.onLoadComplete.isDirty = false;
+  }
+  // onPageChange: optional
+  if (newViewProps.onPageChange.isDirty) {
+    swiftPart.setOnPageChange(newViewProps.onPageChange.value);
+    newViewProps.onPageChange.isDirty = false;
+  }
+  // onScaleChange: optional
+  if (newViewProps.onScaleChange.isDirty) {
+    swiftPart.setOnScaleChange(newViewProps.onScaleChange.value);
+    newViewProps.onScaleChange.isDirty = false;
+  }
+  // onError: optional
+  if (newViewProps.onError.isDirty) {
+    swiftPart.setOnError(newViewProps.onError.value);
+    newViewProps.onError.isDirty = false;
+  }
+  // onThumbnailGenerated: optional
+  if (newViewProps.onThumbnailGenerated.isDirty) {
+    swiftPart.setOnThumbnailGenerated(newViewProps.onThumbnailGenerated.value);
+    newViewProps.onThumbnailGenerated.isDirty = false;
+  }
+  // onLoadingChange: optional
+  if (newViewProps.onLoadingChange.isDirty) {
+    swiftPart.setOnLoadingChange(newViewProps.onLoadingChange.value);
+    newViewProps.onLoadingChange.isDirty = false;
+  }
+
+  swiftPart.afterUpdate();
+
+  // 3. Update hybridRef if it changed
+  if (newViewProps.hybridRef.isDirty) {
+    // hybridRef changed - call it with new this
+    const auto& maybeFunc = newViewProps.hybridRef.value;
+    if (maybeFunc.has_value()) {
+      maybeFunc.value()(_hybridView);
+    }
+    newViewProps.hybridRef.isDirty = false;
+  }
+
+  // 4. Continue in base class
+  [super updateProps:props oldProps:oldProps];
+}
+
+@end

package/nitrogen/generated/ios/swift/ErrorEvent.swift

@@ -0,0 +1,46 @@
+///
+/// ErrorEvent.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * Represents an instance of `ErrorEvent`, backed by a C++ struct.
+ */
+public typealias ErrorEvent = margelo.nitro.pdfviewer.ErrorEvent
+
+public extension ErrorEvent {
+  private typealias bridge = margelo.nitro.pdfviewer.bridge.swift
+
+  /**
+   * Create a new instance of `ErrorEvent`.
+   */
+  init(message: String, code: String) {
+    self.init(std.string(message), std.string(code))
+  }
+
+  var message: String {
+    @inline(__always)
+    get {
+      return String(self.__message)
+    }
+    @inline(__always)
+    set {
+      self.__message = std.string(newValue)
+    }
+  }
+  
+  var code: String {
+    @inline(__always)
+    get {
+      return String(self.__code)
+    }
+    @inline(__always)
+    set {
+      self.__code = std.string(newValue)
+    }
+  }
+}

package/nitrogen/generated/ios/swift/Func_void_ErrorEvent.swift

@@ -0,0 +1,47 @@
+///
+/// Func_void_ErrorEvent.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+
+/**
+ * Wraps a Swift `(_ event: ErrorEvent) -> Void` as a class.
+ * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`.
+ */
+public final class Func_void_ErrorEvent {
+  public typealias bridge = margelo.nitro.pdfviewer.bridge.swift
+
+  private let closure: (_ event: ErrorEvent) -> Void
+
+  public init(_ closure: @escaping (_ event: ErrorEvent) -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call(event: ErrorEvent) -> Void {
+    self.closure(event)
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  @inline(__always)
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `Func_void_ErrorEvent`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_ErrorEvent>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_ErrorEvent {
+    return Unmanaged<Func_void_ErrorEvent>.fromOpaque(pointer).takeRetainedValue()
+  }
+}

package/nitrogen/generated/ios/swift/Func_void_LoadCompleteEvent.swift

@@ -0,0 +1,47 @@
+///
+/// Func_void_LoadCompleteEvent.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+
+/**
+ * Wraps a Swift `(_ event: LoadCompleteEvent) -> Void` as a class.
+ * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`.
+ */
+public final class Func_void_LoadCompleteEvent {
+  public typealias bridge = margelo.nitro.pdfviewer.bridge.swift
+
+  private let closure: (_ event: LoadCompleteEvent) -> Void
+
+  public init(_ closure: @escaping (_ event: LoadCompleteEvent) -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call(event: LoadCompleteEvent) -> Void {
+    self.closure(event)
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  @inline(__always)
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `Func_void_LoadCompleteEvent`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_LoadCompleteEvent>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_LoadCompleteEvent {
+    return Unmanaged<Func_void_LoadCompleteEvent>.fromOpaque(pointer).takeRetainedValue()
+  }
+}

package/nitrogen/generated/ios/swift/Func_void_LoadingChangeEvent.swift

@@ -0,0 +1,47 @@
+///
+/// Func_void_LoadingChangeEvent.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+
+/**
+ * Wraps a Swift `(_ event: LoadingChangeEvent) -> Void` as a class.
+ * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`.
+ */
+public final class Func_void_LoadingChangeEvent {
+  public typealias bridge = margelo.nitro.pdfviewer.bridge.swift
+
+  private let closure: (_ event: LoadingChangeEvent) -> Void
+
+  public init(_ closure: @escaping (_ event: LoadingChangeEvent) -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call(event: LoadingChangeEvent) -> Void {
+    self.closure(event)
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  @inline(__always)
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `Func_void_LoadingChangeEvent`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_LoadingChangeEvent>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_LoadingChangeEvent {
+    return Unmanaged<Func_void_LoadingChangeEvent>.fromOpaque(pointer).takeRetainedValue()
+  }
+}

package/nitrogen/generated/ios/swift/Func_void_PageChangeEvent.swift

@@ -0,0 +1,47 @@
+///
+/// Func_void_PageChangeEvent.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+
+/**
+ * Wraps a Swift `(_ event: PageChangeEvent) -> Void` as a class.
+ * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`.
+ */
+public final class Func_void_PageChangeEvent {
+  public typealias bridge = margelo.nitro.pdfviewer.bridge.swift
+
+  private let closure: (_ event: PageChangeEvent) -> Void
+
+  public init(_ closure: @escaping (_ event: PageChangeEvent) -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call(event: PageChangeEvent) -> Void {
+    self.closure(event)
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  @inline(__always)
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `Func_void_PageChangeEvent`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_PageChangeEvent>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_PageChangeEvent {
+    return Unmanaged<Func_void_PageChangeEvent>.fromOpaque(pointer).takeRetainedValue()
+  }
+}

package/nitrogen/generated/ios/swift/Func_void_ScaleChangeEvent.swift

@@ -0,0 +1,47 @@
+///
+/// Func_void_ScaleChangeEvent.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+
+/**
+ * Wraps a Swift `(_ event: ScaleChangeEvent) -> Void` as a class.
+ * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`.
+ */
+public final class Func_void_ScaleChangeEvent {
+  public typealias bridge = margelo.nitro.pdfviewer.bridge.swift
+
+  private let closure: (_ event: ScaleChangeEvent) -> Void
+
+  public init(_ closure: @escaping (_ event: ScaleChangeEvent) -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call(event: ScaleChangeEvent) -> Void {
+    self.closure(event)
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  @inline(__always)
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `Func_void_ScaleChangeEvent`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_ScaleChangeEvent>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_ScaleChangeEvent {
+    return Unmanaged<Func_void_ScaleChangeEvent>.fromOpaque(pointer).takeRetainedValue()
+  }
+}