react-native-nitro-unzip 0.1.0

package/lib/typescript/specs/Unzip.nitro.d.ts

@@ -0,0 +1,170 @@
+import type { HybridObject } from "react-native-nitro-modules";
+/**
+ * Progress information for an active extraction.
+ */
+export interface UnzipProgress {
+    /** Number of files extracted so far */
+    extractedFiles: number;
+    /** Total number of files in the archive */
+    totalFiles: number;
+    /** Extraction progress from 0.0 to 1.0 */
+    progress: number;
+    /** Current extraction speed in files per second */
+    speed: number;
+    /** Number of bytes processed so far */
+    processedBytes: number;
+}
+/**
+ * Result returned when an extraction completes successfully.
+ */
+export interface UnzipResult {
+    /** Whether extraction completed successfully */
+    success: boolean;
+    /** Total number of files extracted */
+    extractedFiles: number;
+    /** Total extraction duration in milliseconds */
+    duration: number;
+    /** Average extraction speed in files per second */
+    averageSpeed: number;
+    /** Total bytes extracted */
+    totalBytes: number;
+}
+/**
+ * A single extraction operation. Each call to `Unzip.extract()` returns
+ * an `UnzipTask` instance that can be observed and cancelled independently.
+ *
+ * This is a proper HybridObject — a native instance you interact with
+ * directly, not an opaque task ID.
+ */
+export interface UnzipTask extends HybridObject<{
+    ios: "swift";
+    android: "kotlin";
+}> {
+    /** Unique identifier for this extraction task */
+    readonly taskId: string;
+    /**
+     * Register a callback to receive progress updates.
+     * Progress is throttled to ~1 update per second to avoid bridge overhead.
+     * The first file and final file always trigger a callback.
+     */
+    onProgress(callback: (progress: UnzipProgress) => void): void;
+    /** Cancel this extraction. Safe to call multiple times. */
+    cancel(): void;
+    /**
+     * Await the extraction result. Resolves when extraction completes,
+     * rejects if cancelled or an error occurs.
+     */
+    await(): Promise<UnzipResult>;
+}
+/**
+ * Progress information for an active zip creation.
+ */
+export interface ZipProgress {
+    /** Number of files compressed so far */
+    compressedFiles: number;
+    /** Total number of files to compress */
+    totalFiles: number;
+    /** Compression progress from 0.0 to 1.0 */
+    progress: number;
+    /** Current compression speed in files per second */
+    speed: number;
+}
+/**
+ * Result returned when zip creation completes successfully.
+ */
+export interface ZipResult {
+    /** Whether compression completed successfully */
+    success: boolean;
+    /** Total number of files compressed */
+    compressedFiles: number;
+    /** Total compression duration in milliseconds */
+    duration: number;
+    /** Average compression speed in files per second */
+    averageSpeed: number;
+    /** Total bytes written to the zip file */
+    totalBytes: number;
+}
+/**
+ * A single zip creation operation. Each call to `Unzip.zip()` returns
+ * a `ZipTask` instance that can be observed and cancelled independently.
+ */
+export interface ZipTask extends HybridObject<{
+    ios: "swift";
+    android: "kotlin";
+}> {
+    /** Unique identifier for this zip task */
+    readonly taskId: string;
+    /**
+     * Register a callback to receive progress updates.
+     * Progress is throttled to ~1 update per second.
+     */
+    onProgress(callback: (progress: ZipProgress) => void): void;
+    /** Cancel this zip creation. Safe to call multiple times. */
+    cancel(): void;
+    /**
+     * Await the zip result. Resolves when zip creation completes,
+     * rejects if cancelled or an error occurs.
+     */
+    await(): Promise<ZipResult>;
+}
+/**
+ * Factory for creating extraction and compression tasks.
+ *
+ * @example
+ * ```typescript
+ * import { getUnzip } from 'react-native-nitro-unzip'
+ *
+ * const unzip = getUnzip()
+ *
+ * // Extract
+ * const task = unzip.extract('/path/to/archive.zip', '/path/to/output')
+ * task.onProgress((p) => console.log(`${(p.progress * 100).toFixed(0)}%`))
+ * const result = await task.await()
+ *
+ * // Extract with password
+ * const pwTask = unzip.extractWithPassword('/path/to/encrypted.zip', '/output', 'secret')
+ * const pwResult = await pwTask.await()
+ *
+ * // Create zip
+ * const zipTask = unzip.zip('/path/to/folder', '/path/to/output.zip')
+ * const zipResult = await zipTask.await()
+ * ```
+ */
+export interface Unzip extends HybridObject<{
+    ios: "swift";
+    android: "kotlin";
+}> {
+    /**
+     * Start extracting a ZIP archive to the given destination directory.
+     * Returns an `UnzipTask` instance for progress tracking and cancellation.
+     *
+     * @param zipPath - Absolute path to the ZIP file (file:// URIs accepted)
+     * @param destinationPath - Absolute path to extract into (created if missing)
+     */
+    extract(zipPath: string, destinationPath: string): UnzipTask;
+    /**
+     * Extract a password-protected ZIP archive.
+     *
+     * @param zipPath - Absolute path to the ZIP file
+     * @param destinationPath - Absolute path to extract into
+     * @param password - Password for the encrypted archive
+     */
+    extractWithPassword(zipPath: string, destinationPath: string, password: string): UnzipTask;
+    /**
+     * Create a ZIP archive from a directory.
+     *
+     * @param sourcePath - Absolute path to the directory to compress
+     * @param destinationZipPath - Absolute path for the output ZIP file
+     */
+    zip(sourcePath: string, destinationZipPath: string): ZipTask;
+    /**
+     * Create a password-protected ZIP archive from a directory.
+     * Uses AES-256 encryption on Android, standard zip encryption on iOS.
+     *
+     * @param sourcePath - Absolute path to the directory to compress
+     * @param destinationZipPath - Absolute path for the output ZIP file
+     * @param password - Password to protect the archive
+     */
+    zipWithPassword(sourcePath: string, destinationZipPath: string, password: string): ZipTask;
+}
+//# sourceMappingURL=Unzip.nitro.d.ts.map

package/lib/typescript/specs/Unzip.nitro.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Unzip.nitro.d.ts","sourceRoot":"","sources":["../../../src/specs/Unzip.nitro.ts"],"names":[],"mappings":"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"}

package/nitro.json

@@ -0,0 +1,26 @@
+{
+  "$schema": "https://nitro.margelo.com/nitro.schema.json",
+  "cxxNamespace": ["unzip"],
+  "ios": {
+    "iosModuleName": "NitroUnzip"
+  },
+  "android": {
+    "androidNamespace": ["unzip"],
+    "androidCxxLibName": "NitroUnzip"
+  },
+  "autolinking": {
+    "Unzip": {
+      "swift": "HybridUnzip",
+      "kotlin": "HybridUnzip"
+    },
+    "UnzipTask": {
+      "swift": "HybridUnzipTask",
+      "kotlin": "HybridUnzipTask"
+    },
+    "ZipTask": {
+      "swift": "HybridZipTask",
+      "kotlin": "HybridZipTask"
+    }
+  },
+  "ignorePaths": ["node_modules", "lib", "example"]
+}

package/nitrogen/generated/.gitattributes

@@ -0,0 +1 @@
+** linguist-generated=true

package/nitrogen/generated/android/NitroUnzip+autolinking.cmake

@@ -0,0 +1,85 @@
+#
+# NitroUnzip+autolinking.cmake
+# This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+# https://github.com/mrousavy/nitro
+# Copyright © Marc Rousavy @ Margelo
+#
+
+# This is a CMake file that adds all files generated by Nitrogen
+# to the current CMake project.
+#
+# To use it, add this to your CMakeLists.txt:
+# ```cmake
+# include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/NitroUnzip+autolinking.cmake)
+# ```
+
+# Define a flag to check if we are building properly
+add_definitions(-DBUILDING_NITROUNZIP_WITH_GENERATED_CMAKE_PROJECT)
+
+# Enable Raw Props parsing in react-native (for Nitro Views)
+add_definitions(-DRN_SERIALIZABLE_STATE)
+
+# Add all headers that were generated by Nitrogen
+include_directories(
+  "../nitrogen/generated/shared/c++"
+  "../nitrogen/generated/android/c++"
+  "../nitrogen/generated/android/"
+)
+
+# Add all .cpp sources that were generated by Nitrogen
+target_sources(
+  # CMake project name (Android C++ library name)
+  NitroUnzip PRIVATE
+  # Autolinking Setup
+  ../nitrogen/generated/android/NitroUnzipOnLoad.cpp
+  # Shared Nitrogen C++ sources
+  ../nitrogen/generated/shared/c++/HybridUnzipTaskSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridZipTaskSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridUnzipSpec.cpp
+  # Android-specific Nitrogen C++ sources
+  ../nitrogen/generated/android/c++/JHybridUnzipTaskSpec.cpp
+  ../nitrogen/generated/android/c++/JHybridZipTaskSpec.cpp
+  ../nitrogen/generated/android/c++/JHybridUnzipSpec.cpp
+)
+
+# From node_modules/react-native/ReactAndroid/cmake-utils/folly-flags.cmake
+# Used in node_modules/react-native/ReactAndroid/cmake-utils/ReactNative-application.cmake
+target_compile_definitions(
+  NitroUnzip PRIVATE
+  -DFOLLY_NO_CONFIG=1
+  -DFOLLY_HAVE_CLOCK_GETTIME=1
+  -DFOLLY_USE_LIBCPP=1
+  -DFOLLY_CFG_NO_COROUTINES=1
+  -DFOLLY_MOBILE=1
+  -DFOLLY_HAVE_RECVMMSG=1
+  -DFOLLY_HAVE_PTHREAD=1
+  # Once we target android-23 above, we can comment
+  # the following line. NDK uses GNU style stderror_r() after API 23.
+  -DFOLLY_HAVE_XSI_STRERROR_R=1
+)
+
+# Add all libraries required by the generated specs
+find_package(fbjni REQUIRED) # <-- Used for communication between Java <-> C++
+find_package(ReactAndroid REQUIRED) # <-- Used to set up React Native bindings (e.g. CallInvoker/TurboModule)
+find_package(react-native-nitro-modules REQUIRED) # <-- Used to create all HybridObjects and use the Nitro core library
+
+# Link all libraries together
+target_link_libraries(
+        NitroUnzip
+        fbjni::fbjni                              # <-- Facebook C++ JNI helpers
+        ReactAndroid::jsi                         # <-- RN: JSI
+        react-native-nitro-modules::NitroModules  # <-- NitroModules Core :)
+)
+
+# Link react-native (different prefab between RN 0.75 and RN 0.76)
+if(ReactAndroid_VERSION_MINOR GREATER_EQUAL 76)
+    target_link_libraries(
+        NitroUnzip
+        ReactAndroid::reactnative                 # <-- RN: Native Modules umbrella prefab
+    )
+else()
+    target_link_libraries(
+        NitroUnzip
+        ReactAndroid::react_nativemodule_core     # <-- RN: TurboModules Core
+    )
+endif()

package/nitrogen/generated/android/NitroUnzip+autolinking.gradle

@@ -0,0 +1,27 @@
+///
+/// NitroUnzip+autolinking.gradle
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+/// This is a Gradle file that adds all files generated by Nitrogen
+/// to the current Gradle project.
+///
+/// To use it, add this to your build.gradle:
+/// ```gradle
+/// apply from: '../nitrogen/generated/android/NitroUnzip+autolinking.gradle'
+/// ```
+
+logger.warn("[NitroModules] 🔥 NitroUnzip is boosted by nitro!")
+
+android {
+  sourceSets {
+    main {
+      java.srcDirs += [
+        // Nitrogen files
+        "${project.projectDir}/../nitrogen/generated/android/kotlin"
+      ]
+    }
+  }
+}

package/nitrogen/generated/android/NitroUnzipOnLoad.cpp

@@ -0,0 +1,71 @@
+///
+/// NitroUnzipOnLoad.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#ifndef BUILDING_NITROUNZIP_WITH_GENERATED_CMAKE_PROJECT
+#error NitroUnzipOnLoad.cpp is not being built with the autogenerated CMakeLists.txt project. Is a different CMakeLists.txt building this?
+#endif
+
+#include "NitroUnzipOnLoad.hpp"
+
+#include <jni.h>
+#include <fbjni/fbjni.h>
+#include <NitroModules/HybridObjectRegistry.hpp>
+
+#include "JHybridUnzipTaskSpec.hpp"
+#include "JFunc_void_UnzipProgress.hpp"
+#include "JHybridZipTaskSpec.hpp"
+#include "JFunc_void_ZipProgress.hpp"
+#include "JHybridUnzipSpec.hpp"
+#include <NitroModules/DefaultConstructableObject.hpp>
+
+namespace margelo::nitro::unzip {
+
+int initialize(JavaVM* vm) {
+  return facebook::jni::initialize(vm, []() {
+    ::margelo::nitro::unzip::registerAllNatives();
+  });
+}
+
+void registerAllNatives() {
+  using namespace margelo::nitro;
+  using namespace margelo::nitro::unzip;
+
+    // Register native JNI methods
+  margelo::nitro::unzip::JHybridUnzipTaskSpec::registerNatives();
+  margelo::nitro::unzip::JFunc_void_UnzipProgress_cxx::registerNatives();
+  margelo::nitro::unzip::JHybridZipTaskSpec::registerNatives();
+  margelo::nitro::unzip::JFunc_void_ZipProgress_cxx::registerNatives();
+  margelo::nitro::unzip::JHybridUnzipSpec::registerNatives();
+
+  // Register Nitro Hybrid Objects
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Unzip",
+    []() -> std::shared_ptr<HybridObject> {
+      static DefaultConstructableObject<JHybridUnzipSpec::javaobject> object("com/margelo/nitro/unzip/HybridUnzip");
+      auto instance = object.create();
+      return instance->cthis()->shared();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "UnzipTask",
+    []() -> std::shared_ptr<HybridObject> {
+      static DefaultConstructableObject<JHybridUnzipTaskSpec::javaobject> object("com/margelo/nitro/unzip/HybridUnzipTask");
+      auto instance = object.create();
+      return instance->cthis()->shared();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "ZipTask",
+    []() -> std::shared_ptr<HybridObject> {
+      static DefaultConstructableObject<JHybridZipTaskSpec::javaobject> object("com/margelo/nitro/unzip/HybridZipTask");
+      auto instance = object.create();
+      return instance->cthis()->shared();
+    }
+  );
+}
+
+} // namespace margelo::nitro::unzip

package/nitrogen/generated/android/NitroUnzipOnLoad.hpp

@@ -0,0 +1,34 @@
+///
+/// NitroUnzipOnLoad.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include <jni.h>
+#include <functional>
+#include <NitroModules/NitroDefines.hpp>
+
+namespace margelo::nitro::unzip {
+
+  [[deprecated("Use registerNatives() instead.")]]
+  int initialize(JavaVM* vm);
+
+  /**
+   * Register the native (C++) part of NitroUnzip, and autolinks all Hybrid Objects.
+   * Call this in your `JNI_OnLoad` function (probably inside `cpp-adapter.cpp`),
+   * inside a `facebook::jni::initialize(vm, ...)` call.
+   * Example:
+   * ```cpp (cpp-adapter.cpp)
+   * JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+   *   return facebook::jni::initialize(vm, []() {
+   *     // register all NitroUnzip HybridObjects
+   *     margelo::nitro::unzip::registerNatives();
+   *     // any other custom registrations go here.
+   *   });
+   * }
+   * ```
+   */
+  void registerAllNatives();
+
+} // namespace margelo::nitro::unzip

package/nitrogen/generated/android/c++/JFunc_void_UnzipProgress.hpp

@@ -0,0 +1,77 @@
+///
+/// JFunc_void_UnzipProgress.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include "UnzipProgress.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JUnzipProgress.hpp"
+
+namespace margelo::nitro::unzip {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(progress: UnzipProgress) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_UnzipProgress: public jni::JavaClass<JFunc_void_UnzipProgress> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/unzip/Func_void_UnzipProgress;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_UnzipProgress` instance holds through JNI.
+     */
+    void invoke(const UnzipProgress& progress) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JUnzipProgress> /* progress */)>("invoke");
+      method(self(), JUnzipProgress::fromCpp(progress));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_UnzipProgress that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_UnzipProgress_cxx final: public jni::HybridClass<JFunc_void_UnzipProgress_cxx, JFunc_void_UnzipProgress> {
+  public:
+    static jni::local_ref<JFunc_void_UnzipProgress::javaobject> fromCpp(const std::function<void(const UnzipProgress& /* progress */)>& func) {
+      return JFunc_void_UnzipProgress_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_UnzipProgress_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JUnzipProgress> progress) {
+      _func(progress->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const UnzipProgress& /* progress */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/unzip/Func_void_UnzipProgress_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_UnzipProgress_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_UnzipProgress_cxx(const std::function<void(const UnzipProgress& /* progress */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const UnzipProgress& /* progress */)> _func;
+  };
+
+} // namespace margelo::nitro::unzip

package/nitrogen/generated/android/c++/JFunc_void_ZipProgress.hpp

@@ -0,0 +1,77 @@
+///
+/// JFunc_void_ZipProgress.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include "ZipProgress.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JZipProgress.hpp"
+
+namespace margelo::nitro::unzip {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(progress: ZipProgress) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_ZipProgress: public jni::JavaClass<JFunc_void_ZipProgress> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/unzip/Func_void_ZipProgress;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_ZipProgress` instance holds through JNI.
+     */
+    void invoke(const ZipProgress& progress) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JZipProgress> /* progress */)>("invoke");
+      method(self(), JZipProgress::fromCpp(progress));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_ZipProgress that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_ZipProgress_cxx final: public jni::HybridClass<JFunc_void_ZipProgress_cxx, JFunc_void_ZipProgress> {
+  public:
+    static jni::local_ref<JFunc_void_ZipProgress::javaobject> fromCpp(const std::function<void(const ZipProgress& /* progress */)>& func) {
+      return JFunc_void_ZipProgress_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_ZipProgress_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JZipProgress> progress) {
+      _func(progress->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const ZipProgress& /* progress */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/unzip/Func_void_ZipProgress_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_ZipProgress_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_ZipProgress_cxx(const std::function<void(const ZipProgress& /* progress */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const ZipProgress& /* progress */)> _func;
+  };
+
+} // namespace margelo::nitro::unzip

package/nitrogen/generated/android/c++/JHybridUnzipSpec.cpp

@@ -0,0 +1,82 @@
+///
+/// JHybridUnzipSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "JHybridUnzipSpec.hpp"
+
+// Forward declaration of `HybridUnzipTaskSpec` to properly resolve imports.
+namespace margelo::nitro::unzip { class HybridUnzipTaskSpec; }
+// Forward declaration of `HybridZipTaskSpec` to properly resolve imports.
+namespace margelo::nitro::unzip { class HybridZipTaskSpec; }
+
+#include <memory>
+#include "HybridUnzipTaskSpec.hpp"
+#include "JHybridUnzipTaskSpec.hpp"
+#include "HybridZipTaskSpec.hpp"
+#include "JHybridZipTaskSpec.hpp"
+#include <string>
+
+namespace margelo::nitro::unzip {
+
+  jni::local_ref<JHybridUnzipSpec::jhybriddata> JHybridUnzipSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  void JHybridUnzipSpec::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridUnzipSpec::initHybrid),
+    });
+  }
+
+  size_t JHybridUnzipSpec::getExternalMemorySize() noexcept {
+    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
+    return method(_javaPart);
+  }
+
+  bool JHybridUnzipSpec::equals(const std::shared_ptr<HybridObject>& other) {
+    if (auto otherCast = std::dynamic_pointer_cast<JHybridUnzipSpec>(other)) {
+      return _javaPart == otherCast->_javaPart;
+    }
+    return false;
+  }
+
+  void JHybridUnzipSpec::dispose() noexcept {
+    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
+    method(_javaPart);
+  }
+
+  std::string JHybridUnzipSpec::toString() {
+    static const auto method = javaClassStatic()->getMethod<jni::JString()>("toString");
+    auto javaString = method(_javaPart);
+    return javaString->toStdString();
+  }
+
+  // Properties
+  
+
+  // Methods
+  std::shared_ptr<HybridUnzipTaskSpec> JHybridUnzipSpec::extract(const std::string& zipPath, const std::string& destinationPath) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JHybridUnzipTaskSpec::javaobject>(jni::alias_ref<jni::JString> /* zipPath */, jni::alias_ref<jni::JString> /* destinationPath */)>("extract");
+    auto __result = method(_javaPart, jni::make_jstring(zipPath), jni::make_jstring(destinationPath));
+    return __result->cthis()->shared_cast<JHybridUnzipTaskSpec>();
+  }
+  std::shared_ptr<HybridUnzipTaskSpec> JHybridUnzipSpec::extractWithPassword(const std::string& zipPath, const std::string& destinationPath, const std::string& password) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JHybridUnzipTaskSpec::javaobject>(jni::alias_ref<jni::JString> /* zipPath */, jni::alias_ref<jni::JString> /* destinationPath */, jni::alias_ref<jni::JString> /* password */)>("extractWithPassword");
+    auto __result = method(_javaPart, jni::make_jstring(zipPath), jni::make_jstring(destinationPath), jni::make_jstring(password));
+    return __result->cthis()->shared_cast<JHybridUnzipTaskSpec>();
+  }
+  std::shared_ptr<HybridZipTaskSpec> JHybridUnzipSpec::zip(const std::string& sourcePath, const std::string& destinationZipPath) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JHybridZipTaskSpec::javaobject>(jni::alias_ref<jni::JString> /* sourcePath */, jni::alias_ref<jni::JString> /* destinationZipPath */)>("zip");
+    auto __result = method(_javaPart, jni::make_jstring(sourcePath), jni::make_jstring(destinationZipPath));
+    return __result->cthis()->shared_cast<JHybridZipTaskSpec>();
+  }
+  std::shared_ptr<HybridZipTaskSpec> JHybridUnzipSpec::zipWithPassword(const std::string& sourcePath, const std::string& destinationZipPath, const std::string& password) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JHybridZipTaskSpec::javaobject>(jni::alias_ref<jni::JString> /* sourcePath */, jni::alias_ref<jni::JString> /* destinationZipPath */, jni::alias_ref<jni::JString> /* password */)>("zipWithPassword");
+    auto __result = method(_javaPart, jni::make_jstring(sourcePath), jni::make_jstring(destinationZipPath), jni::make_jstring(password));
+    return __result->cthis()->shared_cast<JHybridZipTaskSpec>();
+  }
+
+} // namespace margelo::nitro::unzip