pinata 2.3.0 → 2.4.1

package/dist/index.js

@@ -1,105 +1,11 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+'use strict';
 
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  AuthenticationError: () => AuthenticationError,
-  NetworkError: () => NetworkError,
-  PinataError: () => PinataError,
-  PinataSDK: () => PinataSDK,
-  ValidationError: () => ValidationError,
-  addToGroup: () => addToGroup,
-  analyticsDateInterval: () => analyticsDateInterval,
-  analyticsTopUsage: () => analyticsTopUsage,
-  containsCID: () => containsCID,
-  convertIPFSUrl: () => convertIPFSUrl,
-  convertToDesiredGateway: () => convertToDesiredGateway,
-  createAccessLink: () => createAccessLink,
-  createGroup: () => createGroup,
-  createKey: () => createKey,
-  createSignedUploadURL: () => createSignedUploadURL,
-  deleteFile: () => deleteFile,
-  deleteFileVectors: () => deleteFileVectors,
-  deleteGroup: () => deleteGroup,
-  deletePinRequest: () => deletePinRequest,
-  deleteSwap: () => deleteSwap,
-  formatConfig: () => formatConfig,
-  getCid: () => getCid,
-  getFileIdFromUrl: () => getFileIdFromUrl,
-  getGroup: () => getGroup,
-  listFiles: () => listFiles,
-  listGroups: () => listGroups,
-  listKeys: () => listKeys,
-  pinnedFileCount: () => pinnedFileCount,
-  queue: () => queue,
-  removeFromGroup: () => removeFromGroup,
-  revokeKeys: () => revokeKeys,
-  swapCid: () => swapCid,
-  swapHistory: () => swapHistory,
-  testAuthentication: () => testAuthentication,
-  totalStorageUsage: () => totalStorageUsage,
-  updateFile: () => updateFile,
-  updateGroup: () => updateGroup,
-  uploadBase64: () => uploadBase64,
-  uploadCid: () => uploadCid,
-  uploadFile: () => uploadFile,
-  uploadFileArray: () => uploadFileArray,
-  uploadJson: () => uploadJson,
-  uploadUrl: () => uploadUrl,
-  vectorizeFile: () => vectorizeFile,
-  vectorizeQuery: () => vectorizeQuery
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/utils/custom-errors.ts
-var PinataError = class extends Error {
-  constructor(message, statusCode, details) {
-    super(message);
-    this.statusCode = statusCode;
-    this.details = details;
-    this.name = "PinataError";
-  }
-};
-var NetworkError = class extends PinataError {
-  constructor(message, statusCode, details) {
-    super(message, statusCode, details);
-    this.name = "NetworkError";
-  }
-};
-var AuthenticationError = class extends PinataError {
-  constructor(message, statusCode, details) {
-    super(message, statusCode, details);
-    this.name = "AuthenticationError";
-  }
-};
-var ValidationError = class extends PinataError {
-  constructor(message, details) {
-    super(message, void 0, details);
-    this.name = "ValidationError";
-  }
-};
+var chunkP556VRQU_js = require('./chunk-P556VRQU.js');
 
 // src/core/functions/analytics/analyticsDateInterval.ts
 var analyticsDateInterval = async (config, options) => {
   if (!config) {
-    throw new ValidationError("Pinata configuration is missing");
+    throw new chunkP556VRQU_js.ValidationError("Pinata configuration is missing");
   }
   const params = new URLSearchParams();
   if (options) {
@@ -154,7 +60,7 @@ var analyticsDateInterval = async (config, options) => {
     if (!request.ok) {
       const errorData = await request.text();
       if (request.status === 401 || request.status === 403) {
-        throw new AuthenticationError(
+        throw new chunkP556VRQU_js.AuthenticationError(
           `Authentication failed: ${errorData}`,
           request.status,
           {
@@ -166,7 +72,7 @@ var analyticsDateInterval = async (config, options) => {
           }
         );
       }
-      throw new NetworkError(`HTTP error: ${errorData}`, request.status, {
+      throw new chunkP556VRQU_js.NetworkError(`HTTP error: ${errorData}`, request.status, {
         error: errorData,
         code: "HTTP_ERROR",
         metadata: {
@@ -178,15 +84,15 @@ var analyticsDateInterval = async (config, options) => {
     const resData = res.data;
     return resData;
   } catch (error) {
-    if (error instanceof PinataError) {
+    if (error instanceof chunkP556VRQU_js.PinataError) {
       throw error;
     }
     if (error instanceof Error) {
-      throw new PinataError(
+      throw new chunkP556VRQU_js.PinataError(
         `Error processing anaytics usage: ${error.message}`
       );
     }
-    throw new PinataError(
+    throw new chunkP556VRQU_js.PinataError(
       "An unknown error occurred while fetching gateway usage"
     );
   }
@@ -195,7 +101,7 @@ var analyticsDateInterval = async (config, options) => {
 // src/core/functions/analytics/analyticsTopUsage.ts
 var analyticsTopUsage = async (config, options) => {
   if (!config) {
-    throw new ValidationError("Pinata configuration is missing");
+    throw new chunkP556VRQU_js.ValidationError("Pinata configuration is missing");
   }
   const params = new URLSearchParams();
   if (options) {
@@ -256,7 +162,7 @@ var analyticsTopUsage = async (config, options) => {
     if (!request.ok) {
       const errorData = await request.text();
       if (request.status === 401 || request.status === 403) {
-        throw new AuthenticationError(
+        throw new chunkP556VRQU_js.AuthenticationError(
           `Authentication failed: ${errorData}`,
           request.status,
           {
@@ -268,7 +174,7 @@ var analyticsTopUsage = async (config, options) => {
           }
         );
       }
-      throw new NetworkError(`HTTP error: ${errorData}`, request.status, {
+      throw new chunkP556VRQU_js.NetworkError(`HTTP error: ${errorData}`, request.status, {
         error: errorData,
         code: "HTTP_ERROR",
         metadata: {
@@ -279,15 +185,15 @@ var analyticsTopUsage = async (config, options) => {
     const res = await request.json();
     return res;
   } catch (error) {
-    if (error instanceof PinataError) {
+    if (error instanceof chunkP556VRQU_js.PinataError) {
       throw error;
     }
     if (error instanceof Error) {
-      throw new PinataError(
+      throw new chunkP556VRQU_js.PinataError(
         `Error processing anaytics usage: ${error.message}`
       );
     }
-    throw new PinataError(
+    throw new chunkP556VRQU_js.PinataError(
       "An unknown error occurred while fetching gateway usage"
     );
   }
@@ -296,7 +202,7 @@ var analyticsTopUsage = async (config, options) => {
 // src/core/functions/authentication/testAuthentication.ts
 var testAuthentication = async (config) => {
   if (!config) {
-    throw new ValidationError("Pinata configuration is missing");
+    throw new chunkP556VRQU_js.ValidationError("Pinata configuration is missing");
   }
   let headers;
   let endpoint = "https://api.pinata.cloud";
@@ -322,7 +228,7 @@ var testAuthentication = async (config) => {
     if (!request.ok) {
       const errorData = await request.text();
       if (request.status === 401 || request.status === 403) {
-        throw new AuthenticationError(
+        throw new chunkP556VRQU_js.AuthenticationError(
           `Authentication failed: ${errorData}`,
           request.status,
           {
@@ -334,7 +240,7 @@ var testAuthentication = async (config) => {
           }
         );
       }
-      throw new NetworkError(`HTTP error: ${errorData}`, request.status, {
+      throw new chunkP556VRQU_js.NetworkError(`HTTP error: ${errorData}`, request.status, {
         error: errorData,
         code: "HTTP_ERROR",
         metadata: {
@@ -345,15 +251,15 @@ var testAuthentication = async (config) => {
     const res = await request.json();
     return res;
   } catch (error) {
-    if (error instanceof PinataError) {
+    if (error instanceof chunkP556VRQU_js.PinataError) {
       throw error;
     }
     if (error instanceof Error) {
-      throw new PinataError(
+      throw new chunkP556VRQU_js.PinataError(
         `Error processing authentication: ${error.message}`
       );
     }
-    throw new PinataError(
+    throw new chunkP556VRQU_js.PinataError(
       "An unknown error occurred while testing authentication"
     );
   }
@@ -367,7 +273,7 @@ var wait = (milliseconds) => {
 };
 var deleteFile = async (config, files, privacy) => {
   if (!config) {
-    throw new ValidationError("Pinata configuration is missing");
+    throw new chunkP556VRQU_js.ValidationError("Pinata configuration is missing");
   }
   const responses = [];
   let headers;
@@ -396,7 +302,7 @@ var deleteFile = async (config, files, privacy) => {
       if (!response.ok) {
         const errorData = await response.text();
         if (response.status === 401) {
-          throw new AuthenticationError(
+          throw new chunkP556VRQU_js.AuthenticationError(
             `Authentication failed: ${errorData}`,
             response.status,
             {
@@ -408,7 +314,7 @@ var deleteFile = async (config, files, privacy) => {
             }
           );
         }
-        throw new NetworkError(`HTTP error`, response.status, {
+        throw new chunkP556VRQU_js.NetworkError(`HTTP error`, response.status, {
           error: errorData,
           code: "HTTP_ERROR",
           metadata: {
@@ -422,7 +328,7 @@ var deleteFile = async (config, files, privacy) => {
       });
     } catch (error) {
       let errorMessage;
-      if (error instanceof PinataError) {
+      if (error instanceof chunkP556VRQU_js.PinataError) {
         errorMessage = error.message;
       } else if (error instanceof Error) {
         errorMessage = `Error deleting file ${id}: ${error.message}`;
@@ -441,7 +347,7 @@ var deleteFile = async (config, files, privacy) => {
 // src/core/functions/files/deleteFileVectors.ts
 var deleteFileVectors = async (config, fileId) => {
   if (!config) {
-    throw new ValidationError("Pinata configuration is missing");
+    throw new chunkP556VRQU_js.ValidationError("Pinata configuration is missing");
   }
   let headers;
   if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
@@ -467,7 +373,7 @@ var deleteFileVectors = async (config, fileId) => {
     if (!request.ok) {
       const errorData = await request.text();
       if (request.status === 401 || request.status === 403) {
-        throw new AuthenticationError(
+        throw new chunkP556VRQU_js.AuthenticationError(
           `Authentication failed: ${errorData}`,
           request.status,
           {
@@ -479,7 +385,7 @@ var deleteFileVectors = async (config, fileId) => {
           }
         );
       }
-      throw new NetworkError(`HTTP error: ${errorData}`, request.status, {
+      throw new chunkP556VRQU_js.NetworkError(`HTTP error: ${errorData}`, request.status, {
         error: errorData,
         code: "HTTP_ERROR",
         metadata: {
@@ -490,22 +396,22 @@ var deleteFileVectors = async (config, fileId) => {
     const res = await request.json();
     return res;
   } catch (error) {
-    if (error instanceof PinataError) {
+    if (error instanceof chunkP556VRQU_js.PinataError) {
       throw error;
     }
     if (error instanceof Error) {
-      throw new PinataError(
+      throw new chunkP556VRQU_js.PinataError(
         `Error processing vectorize file: ${error.message}`
       );
     }
-    throw new PinataError("An unknown error occurred while vectorizing file");
+    throw new chunkP556VRQU_js.PinataError("An unknown error occurred while vectorizing file");
   }
 };
 
 // src/core/functions/files/deleteSwap.ts
 var deleteSwap = async (config, cid, network) => {
   if (!config) {
-    throw new ValidationError("Pinata configuration is missing");
+    throw new chunkP556VRQU_js.ValidationError("Pinata configuration is missing");
   }
   let headers;
   if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
@@ -533,13 +439,13 @@ var deleteSwap = async (config, cid, network) => {
     if (!request.ok) {
       const errorData = await request.text();
       if (request.status === 401 || request.status === 403) {
-        throw new AuthenticationError(`Authentication failed`, request.status, {
+        throw new chunkP556VRQU_js.AuthenticationError(`Authentication failed`, request.status, {
           error: errorData,
           code: "AUTH_ERROR"
         });
       }
       if (request.status === 403) {
-        throw new PinataError(
+        throw new chunkP556VRQU_js.PinataError(
           "Unauthorized CID Swap Deletion",
           request.status,
           {
@@ -549,23 +455,23 @@ var deleteSwap = async (config, cid, network) => {
         );
       }
       if (request.status === 404) {
-        throw new PinataError("CID not pinned to account", request.status, {
+        throw new chunkP556VRQU_js.PinataError("CID not pinned to account", request.status, {
           error: errorData,
           code: "NOT_FOUND"
         });
       }
-      throw new NetworkError(`HTTP error occurred`, request.status, {
+      throw new chunkP556VRQU_js.NetworkError(`HTTP error occurred`, request.status, {
         error: errorData,
         code: "NETWORK_ERROR"
       });
     }
     return request.statusText;
   } catch (error) {
-    if (error instanceof PinataError) {
+    if (error instanceof chunkP556VRQU_js.PinataError) {
       throw error;
     }
     if (error instanceof Error) {
-      throw new PinataError(
+      throw new chunkP556VRQU_js.PinataError(
         `Error processing deleteSwap: ${error.message}`,
         void 0,
         {
@@ -573,7 +479,7 @@ var deleteSwap = async (config, cid, network) => {
         }
       );
     }
-    throw new PinataError(
+    throw new chunkP556VRQU_js.PinataError(
       "An unknown error occurred while deleting swap",
       void 0,
       {
@@ -586,7 +492,7 @@ var deleteSwap = async (config, cid, network) => {
 // src/core/functions/files/list.ts
 var listFiles = async (config, privacy, options) => {
   if (!config) {
-    throw new ValidationError("Pinata configuration is missing");
+    throw new chunkP556VRQU_js.ValidationError("Pinata configuration is missing");
   }
   const params = new URLSearchParams();
   if (options) {
@@ -642,7 +548,7 @@ var listFiles = async (config, privacy, options) => {
     if (!request.ok) {
       const errorData = await request.text();
       if (request.status === 401 || request.status === 403) {
-        throw new AuthenticationError(
+        throw new chunkP556VRQU_js.AuthenticationError(
           `Authentication failed: ${errorData}`,
           request.status,
           {
@@ -654,7 +560,7 @@ var listFiles = async (config, privacy, options) => {
           }
         );
       }
-      throw new NetworkError(`HTTP error: ${errorData}`, request.status, {
+      throw new chunkP556VRQU_js.NetworkError(`HTTP error: ${errorData}`, request.status, {
         error: errorData,
         code: "HTTP_ERROR",
         metadata: {
@@ -666,20 +572,20 @@ var listFiles = async (config, privacy, options) => {
     const resData = res.data;
     return resData;
   } catch (error) {
-    if (error instanceof PinataError) {
+    if (error instanceof chunkP556VRQU_js.PinataError) {
       throw error;
     }
     if (error instanceof Error) {
-      throw new PinataError(`Error processing list files: ${error.message}`);
+      throw new chunkP556VRQU_js.PinataError(`Error processing list files: ${error.message}`);
     }
-    throw new PinataError("An unknown error occurred while listing files");
+    throw new chunkP556VRQU_js.PinataError("An unknown error occurred while listing files");
   }
 };
 
 // src/core/functions/files/pinnedFileUsage.ts
 var pinnedFileCount = async (config) => {
   if (!config) {
-    throw new ValidationError("Pinata configuration is missing");
+    throw new chunkP556VRQU_js.ValidationError("Pinata configuration is missing");
   }
   let endpoint = "https://api.pinata.cloud";
   if (config.endpointUrl) {
@@ -705,7 +611,7 @@ var pinnedFileCount = async (config) => {
     if (!request.ok) {
       const errorData = await request.text();
       if (request.status === 401 || request.status === 403) {
-        throw new AuthenticationError(
+        throw new chunkP556VRQU_js.AuthenticationError(
           `Authentication failed: ${errorData}`,
           request.status,
           {
@@ -717,7 +623,7 @@ var pinnedFileCount = async (config) => {
           }
         );
       }
-      throw new NetworkError(`HTTP error: ${errorData}`, request.status, {
+      throw new chunkP556VRQU_js.NetworkError(`HTTP error: ${errorData}`, request.status, {
         error: errorData,
         code: "HTTP_ERROR",
         metadata: {
@@ -728,15 +634,15 @@ var pinnedFileCount = async (config) => {
     const res = await request.json();
     return res.pin_count;
   } catch (error) {
-    if (error instanceof PinataError) {
+    if (error instanceof chunkP556VRQU_js.PinataError) {
       throw error;
     }
     if (error instanceof Error) {
-      throw new PinataError(
+      throw new chunkP556VRQU_js.PinataError(
         `Error processing pinnedFileUsage: ${error.message}`
       );
     }
-    throw new PinataError(
+    throw new chunkP556VRQU_js.PinataError(
       "An unknown error occurred while getting pinned file usage"
     );
   }
@@ -745,7 +651,7 @@ var pinnedFileCount = async (config) => {
 // src/core/functions/files/swapCid.ts
 var swapCid = async (config, options, network) => {
   if (!config) {
-    throw new ValidationError("Pinata configuration is missing");
+    throw new chunkP556VRQU_js.ValidationError("Pinata configuration is missing");
   }
   const data = JSON.stringify({
     swap_cid: options.swapCid
@@ -780,7 +686,7 @@ var swapCid = async (config, options, network) => {
     if (!request.ok) {
       const errorData = await request.text();
       if (request.status === 401 || request.status === 403) {
-        throw new AuthenticationError(
+        throw new chunkP556VRQU_js.AuthenticationError(
           `Authentication failed: ${errorData}`,
           request.status,
           {
@@ -793,7 +699,7 @@ var swapCid = async (config, options, network) => {
         );
       }
       if (request.status === 403) {
-        throw new PinataError("Unauthorized CID Swap", request.status, {
+        throw new chunkP556VRQU_js.PinataError("Unauthorized CID Swap", request.status, {
           error: errorData,
           code: "AUTH_ERROR",
           metadata: {
@@ -802,7 +708,7 @@ var swapCid = async (config, options, network) => {
         });
       }
       if (request.status === 404) {
-        throw new PinataError("CID not pinned to account", request.status, {
+        throw new chunkP556VRQU_js.PinataError("CID not pinned to account", request.status, {
           error: errorData,
           code: "HTTP_ERROR",
           metadata: {
@@ -810,7 +716,7 @@ var swapCid = async (config, options, network) => {
           }
         });
       }
-      throw new NetworkError(`HTTP error: ${errorData}`, request.status, {
+      throw new chunkP556VRQU_js.NetworkError(`HTTP error: ${errorData}`, request.status, {
         error: errorData,
         code: "HTTP_ERROR",
         metadata: {
@@ -822,20 +728,20 @@ var swapCid = async (config, options, network) => {
     const resData = res.data;
     return resData;
   } catch (error) {
-    if (error instanceof PinataError) {
+    if (error instanceof chunkP556VRQU_js.PinataError) {
       throw error;
     }
     if (error instanceof Error) {
-      throw new PinataError(`Error processing CID Swap: ${error.message}`);
+      throw new chunkP556VRQU_js.PinataError(`Error processing CID Swap: ${error.message}`);
     }
-    throw new PinataError("An unknown error occurred while swapping CID");
+    throw new chunkP556VRQU_js.PinataError("An unknown error occurred while swapping CID");
   }
 };
 
 // src/core/functions/files/swapHistory.ts
 var swapHistory = async (config, options, network) => {
   if (!config) {
-    throw new ValidationError("Pinata configuration is missing");
+    throw new chunkP556VRQU_js.ValidationError("Pinata configuration is missing");
   }
   let headers;
   if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
@@ -866,7 +772,7 @@ var swapHistory = async (config, options, network) => {
     if (!request.ok) {
       const errorData = await request.text();
       if (request.status === 401 || request.status === 403) {
-        throw new AuthenticationError(
+        throw new chunkP556VRQU_js.AuthenticationError(
           `Authentication failed: ${errorData}`,
           request.status,
           {
@@ -879,7 +785,7 @@ var swapHistory = async (config, options, network) => {
         );
       }
       if (request.status === 404) {
-        throw new PinataError("CID does not have history", request.status, {
+        throw new chunkP556VRQU_js.PinataError("CID does not have history", request.status, {
           error: errorData,
           code: "HTTP_ERROR",
           metadata: {
@@ -887,7 +793,7 @@ var swapHistory = async (config, options, network) => {
           }
         });
       }
-      throw new NetworkError(`HTTP error: ${errorData}`, request.status, {
+      throw new chunkP556VRQU_js.NetworkError(`HTTP error: ${errorData}`, request.status, {
         error: errorData,
         code: "HTTP_ERROR",
         metadata: {
@@ -899,13 +805,13 @@ var swapHistory = async (config, options, network) => {
     const resData = res.data;
     return resData;
   } catch (error) {
-    if (error instanceof PinataError) {
+    if (error instanceof chunkP556VRQU_js.PinataError) {
       throw error;
     }
     if (error instanceof Error) {
-      throw new PinataError(`Error fetching swap history: ${error.message}`);
+      throw new chunkP556VRQU_js.PinataError(`Error fetching swap history: ${error.message}`);
     }
-    throw new PinataError(
+    throw new chunkP556VRQU_js.PinataError(
       "An unknown error occurred while fetching swap history"
     );
   }
@@ -914,7 +820,7 @@ var swapHistory = async (config, options, network) => {
 // src/core/functions/files/totalStorageUsage.ts
 var totalStorageUsage = async (config) => {
   if (!config) {
-    throw new ValidationError("Pinata configuration is missing");
+    throw new chunkP556VRQU_js.ValidationError("Pinata configuration is missing");
   }
   let endpoint = "https://api.pinata.cloud";
   if (config.endpointUrl) {
@@ -937,7 +843,7 @@ var totalStorageUsage = async (config) => {
     if (!request.ok) {
       const errorData = await request.text();
       if (request.status === 401 || request.status === 403) {
-        throw new AuthenticationError(
+        throw new chunkP556VRQU_js.AuthenticationError(
           `Authentication failed: ${errorData}`,
           request.status,
           {
@@ -949,7 +855,7 @@ var totalStorageUsage = async (config) => {
           }
         );
       }
-      throw new NetworkError(`HTTP error: ${errorData}`, request.status, {
+      throw new chunkP556VRQU_js.NetworkError(`HTTP error: ${errorData}`, request.status, {
         error: errorData,
         code: "HTTP_ERROR",
         metadata: {
@@ -960,15 +866,15 @@ var totalStorageUsage = async (config) => {
     const res = await request.json();
     return res.pin_size_total;
   } catch (error) {
-    if (error instanceof PinataError) {
+    if (error instanceof chunkP556VRQU_js.PinataError) {
       throw error;
     }
     if (error instanceof Error) {
-      throw new PinataError(
+      throw new chunkP556VRQU_js.PinataError(
         `Error processing totalStorageUsage: ${error.message}`
       );
     }
-    throw new PinataError(
+    throw new chunkP556VRQU_js.PinataError(
       "An unknown error occurred while getting total storage usage"
     );
   }
@@ -977,10 +883,10 @@ var totalStorageUsage = async (config) => {
 // src/core/functions/files/updateFile.ts
 var updateFile = async (config, options, privacy) => {
   if (!config) {
-    throw new ValidationError("Pinata configuration is missing");
+    throw new chunkP556VRQU_js.ValidationError("Pinata configuration is missing");
   }
   if (!options.name && (!options.keyvalues || Object.keys(options.keyvalues).length === 0)) {
-    throw new ValidationError(
+    throw new chunkP556VRQU_js.ValidationError(
       "At least one of 'name' or 'keyvalues' must be provided"
     );
   }
@@ -1019,7 +925,7 @@ var updateFile = async (config, options, privacy) => {
     if (!request.ok) {
       const errorData = await request.text();
       if (request.status === 401 || request.status === 403) {
-        throw new AuthenticationError(
+        throw new chunkP556VRQU_js.AuthenticationError(
           `Authentication failed: ${errorData}`,
           request.status,
           {
@@ -1031,7 +937,7 @@ var updateFile = async (config, options, privacy) => {
           }
         );
       }
-      throw new NetworkError(`HTTP error: ${errorData}`, request.status, {
+      throw new chunkP556VRQU_js.NetworkError(`HTTP error: ${errorData}`, request.status, {
         error: errorData,
         code: "HTTP_ERROR",
         metadata: {
@@ -1043,20 +949,20 @@ var updateFile = async (config, options, privacy) => {
     const resData = res.data;
     return resData;
   } catch (error) {
-    if (error instanceof PinataError) {
+    if (error instanceof chunkP556VRQU_js.PinataError) {
       throw error;
     }
     if (error instanceof Error) {
-      throw new PinataError(`Error processing updateFile: ${error.message}`);
+      throw new chunkP556VRQU_js.PinataError(`Error processing updateFile: ${error.message}`);
     }
-    throw new PinataError("An unknown error occurred while updating file");
+    throw new chunkP556VRQU_js.PinataError("An unknown error occurred while updating file");
   }
 };
 
 // src/core/functions/files/vectorizeFile.ts
 var vectorizeFile = async (config, fileId) => {
   if (!config) {
-    throw new ValidationError("Pinata configuration is missing");
+    throw new chunkP556VRQU_js.ValidationError("Pinata configuration is missing");
   }
   let headers;
   if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
@@ -1082,7 +988,7 @@ var vectorizeFile = async (config, fileId) => {
     if (!request.ok) {
       const errorData = await request.text();
       if (request.status === 401 || request.status === 403) {
-        throw new AuthenticationError(
+        throw new chunkP556VRQU_js.AuthenticationError(
           `Authentication failed: ${errorData}`,
           request.status,
           {
@@ -1094,7 +1000,7 @@ var vectorizeFile = async (config, fileId) => {
           }
         );
       }
-      throw new NetworkError(`HTTP error: ${errorData}`, request.status, {
+      throw new chunkP556VRQU_js.NetworkError(`HTTP error: ${errorData}`, request.status, {
         error: errorData,
         code: "HTTP_ERROR",
         metadata: {
@@ -1105,22 +1011,22 @@ var vectorizeFile = async (config, fileId) => {
     const res = await request.json();
     return res;
   } catch (error) {
-    if (error instanceof PinataError) {
+    if (error instanceof chunkP556VRQU_js.PinataError) {
       throw error;
     }
     if (error instanceof Error) {
-      throw new PinataError(
+      throw new chunkP556VRQU_js.PinataError(
         `Error processing vectorize file: ${error.message}`
       );
     }
-    throw new PinataError("An unknown error occurred while vectorizing file");
+    throw new chunkP556VRQU_js.PinataError("An unknown error occurred while vectorizing file");
   }
 };
 
 // src/core/functions/files/vectorizeQuery.ts
 var vectorizeQuery = async (config, options) => {
   if (!config) {
-    throw new ValidationError("Pinata configuration is missing");
+    throw new chunkP556VRQU_js.ValidationError("Pinata configuration is missing");
   }
   let headers;
   if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
@@ -1153,7 +1059,7 @@ var vectorizeQuery = async (config, options) => {
     if (!request.ok) {
       const errorData = await request.text();
       if (request.status === 401 || request.status === 403) {
-        throw new AuthenticationError(
+        throw new chunkP556VRQU_js.AuthenticationError(
           `Authentication failed: ${errorData}`,
           request.status,
           {
@@ -1165,7 +1071,7 @@ var vectorizeQuery = async (config, options) => {
           }
         );
       }
-      throw new NetworkError(`HTTP error: ${errorData}`, request.status, {
+      throw new chunkP556VRQU_js.NetworkError(`HTTP error: ${errorData}`, request.status, {
         error: errorData,
         code: "HTTP_ERROR",
         metadata: {
@@ -1177,7 +1083,7 @@ var vectorizeQuery = async (config, options) => {
     const resData = res.data;
     if (options.returnFile) {
       if (resData.matches.length === 0) {
-        throw new PinataError(`No files returned in query to fetch`);
+        throw new chunkP556VRQU_js.PinataError(`No files returned in query to fetch`);
       }
       const cid = resData.matches[0].cid;
       const fileRes = await getCid(config, cid, "files");
@@ -1185,22 +1091,22 @@ var vectorizeQuery = async (config, options) => {
     }
     return resData;
   } catch (error) {
-    if (error instanceof PinataError) {
+    if (error instanceof chunkP556VRQU_js.PinataError) {
       throw error;
     }
     if (error instanceof Error) {
-      throw new PinataError(
+      throw new chunkP556VRQU_js.PinataError(
         `Error processing vectorize file: ${error.message}`
       );
     }
-    throw new PinataError("An unknown error occurred while vectorizing file");
+    throw new chunkP556VRQU_js.PinataError("An unknown error occurred while vectorizing file");
   }
 };
 
 // src/core/functions/files/queue.ts
 var queue = async (config, options) => {
   if (!config) {
-    throw new ValidationError("Pinata configuration is missing");
+    throw new chunkP556VRQU_js.ValidationError("Pinata configuration is missing");
   }
   const params = new URLSearchParams({
     includesCount: "false"
@@ -1238,7 +1144,7 @@ var queue = async (config, options) => {
     if (!request.ok) {
       const errorData = await request.text();
       if (request.status === 401 || request.status === 403) {
-        throw new AuthenticationError(
+        throw new chunkP556VRQU_js.AuthenticationError(
           `Authentication failed: ${errorData}`,
           request.status,
           {
@@ -1250,7 +1156,7 @@ var queue = async (config, options) => {
           }
         );
       }
-      throw new NetworkError(`HTTP error: ${errorData}`, request.status, {
+      throw new chunkP556VRQU_js.NetworkError(`HTTP error: ${errorData}`, request.status, {
         error: errorData,
         code: "HTTP_ERROR",
         metadata: {
@@ -1262,20 +1168,20 @@ var queue = async (config, options) => {
     const resData = res.data;
     return resData;
   } catch (error) {
-    if (error instanceof PinataError) {
+    if (error instanceof chunkP556VRQU_js.PinataError) {
       throw error;
     }
     if (error instanceof Error) {
-      throw new PinataError(`Error processing pinJobs: ${error.message}`);
+      throw new chunkP556VRQU_js.PinataError(`Error processing pinJobs: ${error.message}`);
     }
-    throw new PinataError("An unknown error occurred while listing pin jobs");
+    throw new chunkP556VRQU_js.PinataError("An unknown error occurred while listing pin jobs");
   }
 };
 
 // src/core/functions/files/deletePinRequest.ts
 var deletePinRequest = async (config, id) => {
   if (!config) {
-    throw new ValidationError("Pinata configuration is missing");
+    throw new chunkP556VRQU_js.ValidationError("Pinata configuration is missing");
   }
   let headers;
   if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
@@ -1301,7 +1207,7 @@ var deletePinRequest = async (config, id) => {
     if (!response.ok) {
       const errorData = await response.text();
       if (response.status === 401) {
-        throw new AuthenticationError(
+        throw new chunkP556VRQU_js.AuthenticationError(
           `Authentication failed: ${errorData}`,
           response.status,
           {
@@ -1313,7 +1219,7 @@ var deletePinRequest = async (config, id) => {
           }
         );
       }
-      throw new NetworkError(`HTTP error`, response.status, {
+      throw new chunkP556VRQU_js.NetworkError(`HTTP error`, response.status, {
         error: errorData,
         code: "HTTP_ERROR",
         metadata: {
@@ -1323,13 +1229,13 @@ var deletePinRequest = async (config, id) => {
     }
     return "OK";
   } catch (error) {
-    if (error instanceof PinataError) {
+    if (error instanceof chunkP556VRQU_js.PinataError) {
       throw error;
     }
     if (error instanceof Error) {
-      throw new PinataError(`Error deleting pin by request: ${error.message}`);
+      throw new chunkP556VRQU_js.PinataError(`Error deleting pin by request: ${error.message}`);
     }
-    throw new PinataError(
+    throw new chunkP556VRQU_js.PinataError(
       "An unknown error occurred while deleting pin by CID request"
     );
   }
@@ -1338,7 +1244,7 @@ var deletePinRequest = async (config, id) => {
 // src/core/functions/gateway/getCid.ts
 var getCid = async (config, cid, gatewayType, options) => {
   if (!config) {
-    throw new ValidationError("Pinata configuration is missing");
+    throw new chunkP556VRQU_js.ValidationError("Pinata configuration is missing");
   }
   let data;
   let newUrl = `${config?.pinataGateway}/${gatewayType}/${cid}`;
@@ -1371,7 +1277,7 @@ var getCid = async (config, cid, gatewayType, options) => {
     if (!request.ok) {
       const errorData = await request.text();
       if (request.status === 401 || request.status === 403) {
-        throw new AuthenticationError(
+        throw new chunkP556VRQU_js.AuthenticationError(
           `Authentication Failed: ${errorData}`,
           request.status,
           {
@@ -1383,7 +1289,7 @@ var getCid = async (config, cid, gatewayType, options) => {
           }
         );
       }
-      throw new NetworkError(`HTTP error: ${errorData}`, request.status, {
+      throw new chunkP556VRQU_js.NetworkError(`HTTP error: ${errorData}`, request.status, {
         error: errorData,
         code: "HTTP_ERROR",
         metadata: {
@@ -1441,7 +1347,7 @@ var getCid = async (config, cid, gatewayType, options) => {
     if (!request.ok) {
       const errorData = await request.text();
       if (request.status === 401 || request.status === 403) {
-        throw new AuthenticationError(
+        throw new chunkP556VRQU_js.AuthenticationError(
           `Authentication Failed: ${errorData}`,
           request.status,
           {
@@ -1453,7 +1359,7 @@ var getCid = async (config, cid, gatewayType, options) => {
           }
         );
       }
-      throw new NetworkError(`HTTP error: ${errorData}`, request.status, {
+      throw new chunkP556VRQU_js.NetworkError(`HTTP error: ${errorData}`, request.status, {
         error: errorData,
         code: "HTTP_ERROR",
         metadata: {
@@ -1475,119 +1381,23 @@ var getCid = async (config, cid, gatewayType, options) => {
     };
     return res;
   } catch (error) {
-    if (error instanceof PinataError) {
+    if (error instanceof chunkP556VRQU_js.PinataError) {
       throw error;
     }
     if (error instanceof Error) {
-      throw new PinataError(`Error processing getCid: ${error.message}`);
+      throw new chunkP556VRQU_js.PinataError(`Error processing getCid: ${error.message}`);
     }
-    throw new PinataError(
+    throw new chunkP556VRQU_js.PinataError(
       "An unknown error occurred while getting CID contents"
     );
   }
 };
 
-// src/utils/gateway-tools.ts
-function isValidCIDv0(cid) {
-  return /^Qm[1-9A-HJ-NP-Za-km-z]{44}$/.test(cid);
-}
-function isValidCIDv1(cid) {
-  return /^b[a-z2-7]{58,}$/.test(cid);
-}
-function isCID(str) {
-  str = str.trim();
-  return isValidCIDv0(str) || isValidCIDv1(str);
-}
-async function containsCID(input) {
-  if (typeof input !== "string") {
-    throw new Error("Input is not a string");
-  }
-  const startsWithCID = (str) => {
-    const parts = str.split("/");
-    return isCID(parts[0]) ? parts[0] : null;
-  };
-  const directCID = startsWithCID(input);
-  if (directCID) {
-    return {
-      containsCid: true,
-      cid: directCID
-    };
-  }
-  let url;
-  try {
-    url = new URL(input);
-  } catch (error) {
-    const parts = input.split(/\/|\?/);
-    for (const part of parts) {
-      const cid = startsWithCID(part);
-      if (cid) {
-        return {
-          containsCid: true,
-          cid
-        };
-      }
-    }
-    return {
-      containsCid: false,
-      cid: null
-    };
-  }
-  const subdomains = url.hostname.split(".");
-  for (const subdomain of subdomains) {
-    if (isCID(subdomain)) {
-      return {
-        containsCid: true,
-        cid: subdomain
-      };
-    }
-  }
-  const pathParts = url.pathname.split("/");
-  for (const part of pathParts) {
-    const cid = startsWithCID(part);
-    if (cid) {
-      return {
-        containsCid: true,
-        cid
-      };
-    }
-  }
-  return {
-    containsCid: false,
-    cid: null
-  };
-}
-async function convertToDesiredGateway(sourceUrl, desiredGatewayPrefix) {
-  const results = await containsCID(sourceUrl);
-  if (results.containsCid !== true) {
-    throw new Error("url does not contain CID");
-  }
-  if (!sourceUrl.startsWith("https") && !sourceUrl.startsWith("ipfs://")) {
-    return `${desiredGatewayPrefix}/ipfs/${sourceUrl}`;
-  }
-  const urlObj = new URL(sourceUrl);
-  const path = urlObj.pathname + urlObj.search + urlObj.hash;
-  if (sourceUrl.startsWith(`ipfs://${results.cid}`)) {
-    return `${desiredGatewayPrefix}/ipfs/${results.cid}${path}`;
-  }
-  if (sourceUrl.includes(`/ipfs/${results.cid}`)) {
-    return `${desiredGatewayPrefix}${path}`;
-  }
-  if (sourceUrl.includes(`/ipns/${results.cid}`)) {
-    return `${desiredGatewayPrefix}${path}`;
-  }
-  if (urlObj.hostname.includes(results.cid)) {
-    return `${desiredGatewayPrefix}/ipfs/${results.cid}${path}`;
-  }
-  throw new Error(
-    "unsupported URL pattern, please submit a github issue with the URL utilized"
-  );
-}
-
 // src/core/functions/gateway/convertIPFSUrl.ts
 var convertIPFSUrl = async (config, url, gatewayPrefix) => {
   let newUrl;
   let prefix = gatewayPrefix || config?.pinataGateway || "https://gateway.pinata.cloud";
-  newUrl = await convertToDesiredGateway(url, prefix);
+  newUrl = await chunkP556VRQU_js.convertToDesiredGateway(url, prefix);
   if (config?.pinataGatewayKey) {
     `${newUrl}?pinataGatewayToken=${config?.pinataGatewayKey}`;
   }
@@ -1597,7 +1407,7 @@ var convertIPFSUrl = async (config, url, gatewayPrefix) => {
 // src/core/functions/gateway/createAccessLink.ts
 var createAccessLink = async (config, options, imgOpts) => {
   if (!config) {
-    throw new ValidationError("Pinata configuration is missing");
+    throw new chunkP556VRQU_js.ValidationError("Pinata configuration is missing");
   }
   let baseUrl;
   if (options?.gateway) {
@@ -1661,7 +1471,7 @@ var createAccessLink = async (config, options, imgOpts) => {
     if (!request.ok) {
       const errorData = await request.text();
       if (request.status === 401 || request.status === 403) {
-        throw new AuthenticationError(
+        throw new chunkP556VRQU_js.AuthenticationError(
           `Authentication Failed: ${errorData}`,
           request.status,
           {
@@ -1673,7 +1483,7 @@ var createAccessLink = async (config, options, imgOpts) => {
           }
         );
       }
-      throw new NetworkError(`HTTP error: ${errorData}`, request.status, {
+      throw new chunkP556VRQU_js.NetworkError(`HTTP error: ${errorData}`, request.status, {
         error: errorData,
         code: "HTTP_ERROR",
         metadata: {
@@ -1684,22 +1494,22 @@ var createAccessLink = async (config, options, imgOpts) => {
     const res = await request.json();
     return res.data;
   } catch (error) {
-    if (error instanceof PinataError) {
+    if (error instanceof chunkP556VRQU_js.PinataError) {
       throw error;
     }
     if (error instanceof Error) {
-      throw new PinataError(
+      throw new chunkP556VRQU_js.PinataError(
         `Error processing createSignedURL: ${error.message}`
       );
     }
-    throw new PinataError("An unknown error occurred while getting signed url");
+    throw new chunkP556VRQU_js.PinataError("An unknown error occurred while getting signed url");
   }
 };
 
 // src/core/functions/groups/addToGroup.ts
 var addToGroup = async (config, options, privacy) => {
   if (!config) {
-    throw new ValidationError("Pinata configuration is missing");
+    throw new chunkP556VRQU_js.ValidationError("Pinata configuration is missing");
   }
   const wait3 = (milliseconds) => {
     return new Promise((resolve) => {
@@ -1738,7 +1548,7 @@ var addToGroup = async (config, options, privacy) => {
       if (!response.ok) {
         const errorData = await response.text();
         if (response.status === 401) {
-          throw new AuthenticationError(
+          throw new chunkP556VRQU_js.AuthenticationError(
             `Authentication failed: ${errorData}`,
             response.status,
             {
@@ -1750,7 +1560,7 @@ var addToGroup = async (config, options, privacy) => {
             }
           );
         }
-        throw new NetworkError(`HTTP error: ${errorData}`, response.status, {
+        throw new chunkP556VRQU_js.NetworkError(`HTTP error: ${errorData}`, response.status, {
           error: errorData,
           code: "HTTP_ERROR",
           metadata: {
@@ -1764,7 +1574,7 @@ var addToGroup = async (config, options, privacy) => {
       });
     } catch (error) {
       let errorMessage;
-      if (error instanceof PinataError) {
+      if (error instanceof chunkP556VRQU_js.PinataError) {
         errorMessage = error.message;
       } else if (error instanceof Error) {
         errorMessage = `Error adding file ${id} to group: ${error.message}`;
@@ -1783,7 +1593,7 @@ var addToGroup = async (config, options, privacy) => {
 // src/core/functions/groups/createGroup.ts
 var createGroup = async (config, options, privacy) => {
   if (!config) {
-    throw new ValidationError("Pinata configuration is missing");
+    throw new chunkP556VRQU_js.ValidationError("Pinata configuration is missing");
   }
   const data = JSON.stringify({
     name: options.name,
@@ -1816,7 +1626,7 @@ var createGroup = async (config, options, privacy) => {
     if (!request.ok) {
       const errorData = await request.text();
       if (request.status === 401 || request.status === 403) {
-        throw new AuthenticationError(
+        throw new chunkP556VRQU_js.AuthenticationError(
           `Authentication failed: ${errorData}`,
           request.status,
           {
@@ -1828,7 +1638,7 @@ var createGroup = async (config, options, privacy) => {
           }
         );
       }
-      throw new NetworkError(`HTTP error: ${errorData}`, request.status, {
+      throw new chunkP556VRQU_js.NetworkError(`HTTP error: ${errorData}`, request.status, {
         error: errorData,
         code: "HTTP_ERROR",
         metadata: {
@@ -1840,20 +1650,20 @@ var createGroup = async (config, options, privacy) => {
     const resData = res.data;
     return resData;
   } catch (error) {
-    if (error instanceof PinataError) {
+    if (error instanceof chunkP556VRQU_js.PinataError) {
       throw error;
     }
     if (error instanceof Error) {
-      throw new PinataError(`Error processing createGroup: ${error.message}`);
+      throw new chunkP556VRQU_js.PinataError(`Error processing createGroup: ${error.message}`);
     }
-    throw new PinataError("An unknown error occurred while creating a group");
+    throw new chunkP556VRQU_js.PinataError("An unknown error occurred while creating a group");
   }
 };
 
 // src/core/functions/groups/deleteGroup.ts
 var deleteGroup = async (config, options, privacy) => {
   if (!config) {
-    throw new ValidationError("Pinata configuration is missing");
+    throw new chunkP556VRQU_js.ValidationError("Pinata configuration is missing");
   }
   let headers;
   if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
@@ -1884,7 +1694,7 @@ var deleteGroup = async (config, options, privacy) => {
     if (!request.ok) {
       const errorData = await request.text();
       if (request.status === 401 || request.status === 403) {
-        throw new AuthenticationError(
+        throw new chunkP556VRQU_js.AuthenticationError(
           `Authentication failed: ${errorData}`,
           request.status,
           {
@@ -1896,7 +1706,7 @@ var deleteGroup = async (config, options, privacy) => {
           }
         );
       }
-      throw new NetworkError(`HTTP error: ${errorData}`, request.status, {
+      throw new chunkP556VRQU_js.NetworkError(`HTTP error: ${errorData}`, request.status, {
         error: errorData,
         code: "HTTP_ERROR",
         metadata: {
@@ -1907,20 +1717,20 @@ var deleteGroup = async (config, options, privacy) => {
     const res = request.statusText;
     return res;
   } catch (error) {
-    if (error instanceof PinataError) {
+    if (error instanceof chunkP556VRQU_js.PinataError) {
       throw error;
     }
     if (error instanceof Error) {
-      throw new PinataError(`Error processing deleteGroup: ${error.message}`);
+      throw new chunkP556VRQU_js.PinataError(`Error processing deleteGroup: ${error.message}`);
     }
-    throw new PinataError("An unknown error occurred while deleting a group");
+    throw new chunkP556VRQU_js.PinataError("An unknown error occurred while deleting a group");
   }
 };
 
 // src/core/functions/groups/getGroup.ts
 var getGroup = async (config, options, privacy) => {
   if (!config) {
-    throw new ValidationError("Pinata configuration is missing");
+    throw new chunkP556VRQU_js.ValidationError("Pinata configuration is missing");
   }
   let headers;
   if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
@@ -1951,7 +1761,7 @@ var getGroup = async (config, options, privacy) => {
     if (!request.ok) {
       const errorData = await request.text();
       if (request.status === 401 || request.status === 403) {
-        throw new AuthenticationError(
+        throw new chunkP556VRQU_js.AuthenticationError(
           `Authentication failed: ${errorData}`,
           request.status,
           {
@@ -1963,7 +1773,7 @@ var getGroup = async (config, options, privacy) => {
           }
         );
       }
-      throw new NetworkError(`HTTP error: ${errorData}`, request.status, {
+      throw new chunkP556VRQU_js.NetworkError(`HTTP error: ${errorData}`, request.status, {
         error: errorData,
         code: "HTTP_ERROR",
         metadata: {
@@ -1975,13 +1785,13 @@ var getGroup = async (config, options, privacy) => {
     const resData = res.data;
     return resData;
   } catch (error) {
-    if (error instanceof PinataError) {
+    if (error instanceof chunkP556VRQU_js.PinataError) {
       throw error;
     }
     if (error instanceof Error) {
-      throw new PinataError(`Error processing getGroup: ${error.message}`);
+      throw new chunkP556VRQU_js.PinataError(`Error processing getGroup: ${error.message}`);
     }
-    throw new PinataError(
+    throw new chunkP556VRQU_js.PinataError(
       "An unknown error occurred while getting info for a group"
     );
   }
@@ -1990,7 +1800,7 @@ var getGroup = async (config, options, privacy) => {
 // src/core/functions/groups/listGroups.ts
 var listGroups = async (config, privacy, options) => {
   if (!config) {
-    throw new ValidationError("Pinata configuration is missing");
+    throw new chunkP556VRQU_js.ValidationError("Pinata configuration is missing");
   }
   let headers;
   if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
@@ -2029,7 +1839,7 @@ var listGroups = async (config, privacy, options) => {
     if (!request.ok) {
       const errorData = await request.text();
       if (request.status === 401 || request.status === 403) {
-        throw new AuthenticationError(
+        throw new chunkP556VRQU_js.AuthenticationError(
           `Authentication failed: ${errorData}`,
           request.status,
           {
@@ -2041,7 +1851,7 @@ var listGroups = async (config, privacy, options) => {
           }
         );
       }
-      throw new NetworkError(`HTTP error: ${errorData}`, request.status, {
+      throw new chunkP556VRQU_js.NetworkError(`HTTP error: ${errorData}`, request.status, {
         error: errorData,
         code: "HTTP_ERROR",
         metadata: {
@@ -2053,20 +1863,20 @@ var listGroups = async (config, privacy, options) => {
     const resData = res.data;
     return resData;
   } catch (error) {
-    if (error instanceof PinataError) {
+    if (error instanceof chunkP556VRQU_js.PinataError) {
       throw error;
     }
     if (error instanceof Error) {
-      throw new PinataError(`Error processing listGroups: ${error.message}`);
+      throw new chunkP556VRQU_js.PinataError(`Error processing listGroups: ${error.message}`);
     }
-    throw new PinataError("An unknown error occurred while listing groups");
+    throw new chunkP556VRQU_js.PinataError("An unknown error occurred while listing groups");
   }
 };
 
 // src/core/functions/groups/removeFromGroup.ts
 var removeFromGroup = async (config, options, privacy) => {
   if (!config) {
-    throw new ValidationError("Pinata configuration is missing");
+    throw new chunkP556VRQU_js.ValidationError("Pinata configuration is missing");
   }
   const wait3 = (milliseconds) => {
     return new Promise((resolve) => {
@@ -2105,7 +1915,7 @@ var removeFromGroup = async (config, options, privacy) => {
       if (!response.ok) {
         const errorData = await response.text();
         if (response.status === 401) {
-          throw new AuthenticationError(
+          throw new chunkP556VRQU_js.AuthenticationError(
             `Authentication failed: ${errorData}`,
             response.status,
             {
@@ -2117,7 +1927,7 @@ var removeFromGroup = async (config, options, privacy) => {
             }
           );
         }
-        throw new NetworkError(`HTTP error: ${errorData}`, response.status, {
+        throw new chunkP556VRQU_js.NetworkError(`HTTP error: ${errorData}`, response.status, {
           error: errorData,
           code: "HTTP_ERROR",
           metadata: {
@@ -2131,7 +1941,7 @@ var removeFromGroup = async (config, options, privacy) => {
       });
     } catch (error) {
       let errorMessage;
-      if (error instanceof PinataError) {
+      if (error instanceof chunkP556VRQU_js.PinataError) {
         errorMessage = error.message;
       } else if (error instanceof Error) {
         errorMessage = `Error adding file ${id} to group: ${error.message}`;
@@ -2150,7 +1960,7 @@ var removeFromGroup = async (config, options, privacy) => {
 // src/core/functions/groups/updateGroup.ts
 var updateGroup = async (config, options, privacy) => {
   if (!config) {
-    throw new ValidationError("Pinata configuration is missing");
+    throw new chunkP556VRQU_js.ValidationError("Pinata configuration is missing");
   }
   const data = JSON.stringify({
     name: options.name,
@@ -2186,7 +1996,7 @@ var updateGroup = async (config, options, privacy) => {
     if (!request.ok) {
       const errorData = await request.text();
       if (request.status === 401 || request.status === 403) {
-        throw new AuthenticationError(
+        throw new chunkP556VRQU_js.AuthenticationError(
           `Authentication failed: ${errorData}`,
           request.status,
           {
@@ -2198,7 +2008,7 @@ var updateGroup = async (config, options, privacy) => {
           }
         );
       }
-      throw new NetworkError(`HTTP error: ${errorData}`, request.status, {
+      throw new chunkP556VRQU_js.NetworkError(`HTTP error: ${errorData}`, request.status, {
         error: errorData,
         code: "HTTP_ERROR",
         metadata: {
@@ -2210,20 +2020,20 @@ var updateGroup = async (config, options, privacy) => {
     const resData = res.data;
     return resData;
   } catch (error) {
-    if (error instanceof PinataError) {
+    if (error instanceof chunkP556VRQU_js.PinataError) {
       throw error;
     }
     if (error instanceof Error) {
-      throw new PinataError(`Error processing updateGroup: ${error.message}`);
+      throw new chunkP556VRQU_js.PinataError(`Error processing updateGroup: ${error.message}`);
     }
-    throw new PinataError("An unknown error occurred while updating group");
+    throw new chunkP556VRQU_js.PinataError("An unknown error occurred while updating group");
   }
 };
 
 // src/core/functions/keys/createKey.ts
 var createKey = async (config, options) => {
   if (!config) {
-    throw new ValidationError("Pinata configuration is missing");
+    throw new chunkP556VRQU_js.ValidationError("Pinata configuration is missing");
   }
   let headers;
   if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
@@ -2253,7 +2063,7 @@ var createKey = async (config, options) => {
     if (!request.ok) {
       const errorData = await request.text();
       if (request.status === 401 || request.status === 403) {
-        throw new AuthenticationError(
+        throw new chunkP556VRQU_js.AuthenticationError(
           `Authentication failed: ${errorData}`,
           request.status,
           {
@@ -2265,7 +2075,7 @@ var createKey = async (config, options) => {
           }
         );
       }
-      throw new NetworkError(`HTTP error: ${errorData}`, request.status, {
+      throw new chunkP556VRQU_js.NetworkError(`HTTP error: ${errorData}`, request.status, {
         error: errorData,
         code: "HTTP_ERROR",
         metadata: {
@@ -2276,20 +2086,20 @@ var createKey = async (config, options) => {
     const res = await request.json();
     return res;
   } catch (error) {
-    if (error instanceof PinataError) {
+    if (error instanceof chunkP556VRQU_js.PinataError) {
       throw error;
     }
     if (error instanceof Error) {
-      throw new PinataError(`Error processing createKey: ${error.message}`);
+      throw new chunkP556VRQU_js.PinataError(`Error processing createKey: ${error.message}`);
     }
-    throw new PinataError("An unknown error occurred while creating API key");
+    throw new chunkP556VRQU_js.PinataError("An unknown error occurred while creating API key");
   }
 };
 
 // src/core/functions/keys/listKeys.ts
 var listKeys = async (config, options) => {
   if (!config) {
-    throw new ValidationError("Pinata configuration is missing");
+    throw new chunkP556VRQU_js.ValidationError("Pinata configuration is missing");
   }
   let headers;
   if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
@@ -2331,7 +2141,7 @@ var listKeys = async (config, options) => {
     if (!request.ok) {
       const errorData = await request.text();
       if (request.status === 401 || request.status === 403) {
-        throw new AuthenticationError(
+        throw new chunkP556VRQU_js.AuthenticationError(
           `Authentication failed: ${errorData}`,
           request.status,
           {
@@ -2343,7 +2153,7 @@ var listKeys = async (config, options) => {
           }
         );
       }
-      throw new NetworkError(`HTTP error: ${errorData}`, request.status, {
+      throw new chunkP556VRQU_js.NetworkError(`HTTP error: ${errorData}`, request.status, {
         error: errorData,
         code: "HTTP_ERROR",
         metadata: {
@@ -2354,13 +2164,13 @@ var listKeys = async (config, options) => {
     const res = await request.json();
     return res.keys;
   } catch (error) {
-    if (error instanceof PinataError) {
+    if (error instanceof chunkP556VRQU_js.PinataError) {
       throw error;
     }
     if (error instanceof Error) {
-      throw new PinataError(`Error processing listKeys: ${error.message}`);
+      throw new chunkP556VRQU_js.PinataError(`Error processing listKeys: ${error.message}`);
     }
-    throw new PinataError("An unknown error occurred while listing API keys");
+    throw new chunkP556VRQU_js.PinataError("An unknown error occurred while listing API keys");
   }
 };
 
@@ -2372,7 +2182,7 @@ var wait2 = (milliseconds) => {
 };
 var revokeKeys = async (config, keys) => {
   if (!config) {
-    throw new ValidationError("Pinata configuration is missing");
+    throw new chunkP556VRQU_js.ValidationError("Pinata configuration is missing");
   }
   let headers;
   if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
@@ -2404,7 +2214,7 @@ var revokeKeys = async (config, keys) => {
       if (!request.ok) {
         const errorData = await request.text();
         if (request.status === 401 || request.status === 403) {
-          throw new AuthenticationError(
+          throw new chunkP556VRQU_js.AuthenticationError(
             `Authentication failed: ${errorData}`,
             request.status,
             {
@@ -2416,7 +2226,7 @@ var revokeKeys = async (config, keys) => {
             }
           );
         }
-        throw new NetworkError(`HTTP error: ${errorData}`, request.status, {
+        throw new chunkP556VRQU_js.NetworkError(`HTTP error: ${errorData}`, request.status, {
           error: errorData,
           code: "HTTP_ERROR",
           metadata: {
@@ -2431,7 +2241,7 @@ var revokeKeys = async (config, keys) => {
       });
     } catch (error) {
       let errorMessage;
-      if (error instanceof PinataError) {
+      if (error instanceof chunkP556VRQU_js.PinataError) {
         errorMessage = error.message;
       } else if (error instanceof Error) {
         errorMessage = `Error revoking key ${key}: ${error.message}`;
@@ -2450,7 +2260,7 @@ var revokeKeys = async (config, keys) => {
 // src/core/functions/uploads/base64.ts
 var uploadBase64 = async (config, base64String, network, options) => {
   if (!config) {
-    throw new ValidationError("Pinata configuration is missing");
+    throw new chunkP556VRQU_js.ValidationError("Pinata configuration is missing");
   }
   const jwt = options?.keys || config?.pinataJwt;
   const name = options?.metadata?.name ? options?.metadata?.name : "base64 string";
@@ -2491,7 +2301,7 @@ var uploadBase64 = async (config, base64String, network, options) => {
       if (!request.ok) {
         const errorData = await request.text();
         if (request.status === 401 || request.status === 403) {
-          throw new AuthenticationError(
+          throw new chunkP556VRQU_js.AuthenticationError(
             `Authentication failed: ${errorData}`,
             request.status,
             {
@@ -2503,7 +2313,7 @@ var uploadBase64 = async (config, base64String, network, options) => {
             }
           );
         }
-        throw new NetworkError(`HTTP error: ${errorData}`, request.status, {
+        throw new chunkP556VRQU_js.NetworkError(`HTTP error: ${errorData}`, request.status, {
           error: errorData,
           code: "HTTP_ERROR",
           metadata: {
@@ -2515,13 +2325,13 @@ var uploadBase64 = async (config, base64String, network, options) => {
       const resData = res.data;
       return resData;
     } catch (error) {
-      if (error instanceof PinataError) {
+      if (error instanceof chunkP556VRQU_js.PinataError) {
         throw error;
       }
       if (error instanceof Error) {
-        throw new PinataError(`Error processing base64: ${error.message}`);
+        throw new chunkP556VRQU_js.PinataError(`Error processing base64: ${error.message}`);
       }
-      throw new PinataError(
+      throw new chunkP556VRQU_js.PinataError(
         "An unknown error occurred while trying to upload base64"
       );
     }
@@ -2535,7 +2345,7 @@ var uploadBase64 = async (config, base64String, network, options) => {
     if (!request.ok) {
       const errorData = await request.text();
       if (request.status === 401 || request.status === 403) {
-        throw new AuthenticationError(
+        throw new chunkP556VRQU_js.AuthenticationError(
           `Authentication failed: ${errorData}`,
           request.status,
           {
@@ -2547,7 +2357,7 @@ var uploadBase64 = async (config, base64String, network, options) => {
           }
         );
       }
-      throw new NetworkError(`HTTP error: ${errorData}`, request.status, {
+      throw new chunkP556VRQU_js.NetworkError(`HTTP error: ${errorData}`, request.status, {
         error: errorData,
         code: "HTTP_ERROR",
         metadata: {
@@ -2572,7 +2382,7 @@ var uploadBase64 = async (config, base64String, network, options) => {
         return resData;
       } else {
         const errorData = await vectorReq.text();
-        throw new NetworkError(
+        throw new chunkP556VRQU_js.NetworkError(
           `HTTP error during vectorization: ${errorData}`,
           vectorReq.status,
           {
@@ -2587,13 +2397,13 @@ var uploadBase64 = async (config, base64String, network, options) => {
     }
     return resData;
   } catch (error) {
-    if (error instanceof PinataError) {
+    if (error instanceof chunkP556VRQU_js.PinataError) {
       throw error;
     }
     if (error instanceof Error) {
-      throw new PinataError(`Error processing base64: ${error.message}`);
+      throw new chunkP556VRQU_js.PinataError(`Error processing base64: ${error.message}`);
     }
-    throw new PinataError(
+    throw new chunkP556VRQU_js.PinataError(
       "An unknown error occurred while trying to upload base64"
     );
   }
@@ -2602,7 +2412,7 @@ var uploadBase64 = async (config, base64String, network, options) => {
 // src/core/functions/uploads/createSignedUploadURL.ts
 var createSignedUploadURL = async (config, options, network) => {
   if (!config) {
-    throw new ValidationError("Pinata configuration is missing");
+    throw new chunkP556VRQU_js.ValidationError("Pinata configuration is missing");
   }
   const date = options?.date || Math.floor((/* @__PURE__ */ new Date()).getTime() / 1e3);
   const payload = {
@@ -2657,7 +2467,7 @@ var createSignedUploadURL = async (config, options, network) => {
     if (!request.ok) {
       const errorData = await request.text();
       if (request.status === 401 || request.status === 403) {
-        throw new AuthenticationError(
+        throw new chunkP556VRQU_js.AuthenticationError(
           `Authentication Failed: ${errorData}`,
           request.status,
           {
@@ -2669,7 +2479,7 @@ var createSignedUploadURL = async (config, options, network) => {
           }
         );
       }
-      throw new NetworkError(`HTTP error: ${errorData}`, request.status, {
+      throw new chunkP556VRQU_js.NetworkError(`HTTP error: ${errorData}`, request.status, {
         error: errorData,
         code: "HTTP_ERROR",
         metadata: {
@@ -2680,37 +2490,22 @@ var createSignedUploadURL = async (config, options, network) => {
     const res = await request.json();
     return res.data;
   } catch (error) {
-    if (error instanceof PinataError) {
+    if (error instanceof chunkP556VRQU_js.PinataError) {
       throw error;
     }
     if (error instanceof Error) {
-      throw new PinataError(
+      throw new chunkP556VRQU_js.PinataError(
         `Error processing createSignedURL: ${error.message}`
       );
     }
-    throw new PinataError("An unknown error occurred while getting signed url");
+    throw new chunkP556VRQU_js.PinataError("An unknown error occurred while getting signed url");
   }
 };
 
-// src/utils/resumable.ts
-function getFileIdFromUrl(url) {
-  const match = url.match(/\/files\/([^\/]+)/);
-  if (match && match[1]) {
-    return match[1];
-  }
-  throw new NetworkError("File ID not found in URL", 400, {
-    error: "File ID not found in URL",
-    code: "HTTP_ERROR",
-    metadata: {
-      requestUrl: url
-    }
-  });
-}
-
 // src/core/functions/uploads/file.ts
 var uploadFile = async (config, file, network, options) => {
   if (!config) {
-    throw new ValidationError("Pinata configuration is missing");
+    throw new chunkP556VRQU_js.ValidationError("Pinata configuration is missing");
   }
   const jwt = options?.keys || config.pinataJwt;
   let endpoint = "https://uploads.pinata.cloud/v3";
@@ -2756,7 +2551,7 @@ var uploadFile = async (config, file, network, options) => {
     const url = urlReq.headers.get("Location");
     if (!url) {
       const errorData = await urlReq.text();
-      throw new NetworkError("Upload URL not provided", urlReq.status, {
+      throw new chunkP556VRQU_js.NetworkError("Upload URL not provided", urlReq.status, {
         error: errorData,
         code: "HTTP_ERROR",
         metadata: {
@@ -2782,7 +2577,7 @@ var uploadFile = async (config, file, network, options) => {
       });
       if (!uploadReq.ok) {
         const errorData = await uploadReq.text();
-        throw new NetworkError(
+        throw new chunkP556VRQU_js.NetworkError(
           `HTTP error during chunk upload: ${errorData}`,
           uploadReq.status,
           {
@@ -2797,7 +2592,7 @@ var uploadFile = async (config, file, network, options) => {
       offset += chunk.size;
     }
     if (uploadReq.status === 204) {
-      const fileId = getFileIdFromUrl(url);
+      const fileId = chunkP556VRQU_js.getFileIdFromUrl(url);
       let dataEndpoint;
       if (config.endpointUrl) {
         dataEndpoint = config.endpointUrl;
@@ -2830,7 +2625,7 @@ var uploadFile = async (config, file, network, options) => {
           return data2;
         } else {
           const errorData = await vectorReq.text();
-          throw new NetworkError(
+          throw new chunkP556VRQU_js.NetworkError(
             `HTTP error during vectorization: ${errorData}`,
             vectorReq.status,
             {
@@ -2881,7 +2676,7 @@ var uploadFile = async (config, file, network, options) => {
       if (!request.ok) {
         const errorData = await request.text();
         if (request.status === 401 || request.status === 403) {
-          throw new AuthenticationError(
+          throw new chunkP556VRQU_js.AuthenticationError(
             `Authentication failed: ${errorData}`,
             request.status,
             {
@@ -2893,7 +2688,7 @@ var uploadFile = async (config, file, network, options) => {
             }
           );
         }
-        throw new NetworkError(`HTTP error: ${errorData}`, request.status, {
+        throw new chunkP556VRQU_js.NetworkError(`HTTP error: ${errorData}`, request.status, {
           error: errorData,
           code: "HTTP_ERROR",
           metadata: {
@@ -2905,13 +2700,13 @@ var uploadFile = async (config, file, network, options) => {
       const resData = res.data;
       return resData;
     } catch (error) {
-      if (error instanceof PinataError) {
+      if (error instanceof chunkP556VRQU_js.PinataError) {
         throw error;
       }
       if (error instanceof Error) {
-        throw new PinataError(`Error processing base64: ${error.message}`);
+        throw new chunkP556VRQU_js.PinataError(`Error processing base64: ${error.message}`);
       }
-      throw new PinataError(
+      throw new chunkP556VRQU_js.PinataError(
         "An unknown error occurred while trying to upload base64"
       );
     }
@@ -2925,7 +2720,7 @@ var uploadFile = async (config, file, network, options) => {
     if (!request.ok) {
       const errorData = await request.text();
       if (request.status === 401 || request.status === 403) {
-        throw new AuthenticationError(
+        throw new chunkP556VRQU_js.AuthenticationError(
           `Authentication failed: ${errorData}`,
           request.status,
           {
@@ -2937,7 +2732,7 @@ var uploadFile = async (config, file, network, options) => {
           }
         );
       }
-      throw new NetworkError(`HTTP error: ${errorData}`, request.status, {
+      throw new chunkP556VRQU_js.NetworkError(`HTTP error: ${errorData}`, request.status, {
         error: errorData,
         code: "HTTP_ERROR",
         metadata: {
@@ -2962,7 +2757,7 @@ var uploadFile = async (config, file, network, options) => {
         return resData;
       } else {
         const errorData = await vectorReq.text();
-        throw new NetworkError(
+        throw new chunkP556VRQU_js.NetworkError(
           `HTTP error during vectorization: ${errorData}`,
           vectorReq.status,
           {
@@ -2977,20 +2772,20 @@ var uploadFile = async (config, file, network, options) => {
     }
     return resData;
   } catch (error) {
-    if (error instanceof PinataError) {
+    if (error instanceof chunkP556VRQU_js.PinataError) {
       throw error;
     }
     if (error instanceof Error) {
-      throw new PinataError(`Error uploading file: ${error.message}`);
+      throw new chunkP556VRQU_js.PinataError(`Error uploading file: ${error.message}`);
     }
-    throw new PinataError("An unknown error occurred while uploading the file");
+    throw new chunkP556VRQU_js.PinataError("An unknown error occurred while uploading the file");
   }
 };
 
 // src/core/functions/uploads/fileArray.ts
 var uploadFileArray = async (config, files, network, options) => {
   if (!config) {
-    throw new ValidationError("Pinata configuration is missing");
+    throw new chunkP556VRQU_js.ValidationError("Pinata configuration is missing");
   }
   const jwt = options?.keys || config?.pinataJwt;
   const folder = options?.metadata?.name || "folder_from_sdk";
@@ -3038,7 +2833,7 @@ var uploadFileArray = async (config, files, network, options) => {
     if (!request.ok) {
       const errorData = await request.text();
       if (request.status === 401 || request.status === 403) {
-        throw new AuthenticationError(
+        throw new chunkP556VRQU_js.AuthenticationError(
           `Authentication failed: ${errorData}`,
           request.status,
           {
@@ -3050,7 +2845,7 @@ var uploadFileArray = async (config, files, network, options) => {
           }
         );
       }
-      throw new NetworkError(`HTTP error: ${errorData}`, request.status, {
+      throw new chunkP556VRQU_js.NetworkError(`HTTP error: ${errorData}`, request.status, {
         error: errorData,
         code: "HTTP_ERROR",
         metadata: {
@@ -3074,13 +2869,13 @@ var uploadFileArray = async (config, files, network, options) => {
     };
     return resData;
   } catch (error) {
-    if (error instanceof PinataError) {
+    if (error instanceof chunkP556VRQU_js.PinataError) {
       throw error;
     }
     if (error instanceof Error) {
-      throw new PinataError(`Error processing fileArray: ${error.message}`);
+      throw new chunkP556VRQU_js.PinataError(`Error processing fileArray: ${error.message}`);
     }
-    throw new PinataError(
+    throw new chunkP556VRQU_js.PinataError(
       "An unknown error occurred while uploading an array of files"
     );
   }
@@ -3089,7 +2884,7 @@ var uploadFileArray = async (config, files, network, options) => {
 // src/core/functions/uploads/json.ts
 var uploadJson = async (config, jsonData, network, options) => {
   if (!config) {
-    throw new ValidationError("Pinata configuration is missing");
+    throw new chunkP556VRQU_js.ValidationError("Pinata configuration is missing");
   }
   const jwt = options?.keys || config?.pinataJwt;
   const json = JSON.stringify(jsonData);
@@ -3130,7 +2925,7 @@ var uploadJson = async (config, jsonData, network, options) => {
       if (!request.ok) {
         const errorData = await request.text();
         if (request.status === 401 || request.status === 403) {
-          throw new AuthenticationError(
+          throw new chunkP556VRQU_js.AuthenticationError(
             `Authentication failed: ${errorData}`,
             request.status,
             {
@@ -3142,7 +2937,7 @@ var uploadJson = async (config, jsonData, network, options) => {
             }
           );
         }
-        throw new NetworkError(`HTTP error: ${errorData}`, request.status, {
+        throw new chunkP556VRQU_js.NetworkError(`HTTP error: ${errorData}`, request.status, {
           error: errorData,
           code: "HTTP_ERROR",
           metadata: {
@@ -3154,13 +2949,13 @@ var uploadJson = async (config, jsonData, network, options) => {
       const resData = res.data;
       return resData;
     } catch (error) {
-      if (error instanceof PinataError) {
+      if (error instanceof chunkP556VRQU_js.PinataError) {
         throw error;
       }
       if (error instanceof Error) {
-        throw new PinataError(`Error processing base64: ${error.message}`);
+        throw new chunkP556VRQU_js.PinataError(`Error processing base64: ${error.message}`);
       }
-      throw new PinataError(
+      throw new chunkP556VRQU_js.PinataError(
         "An unknown error occurred while trying to upload base64"
       );
     }
@@ -3174,7 +2969,7 @@ var uploadJson = async (config, jsonData, network, options) => {
     if (!request.ok) {
       const errorData = await request.text();
       if (request.status === 401 || request.status === 403) {
-        throw new AuthenticationError(
+        throw new chunkP556VRQU_js.AuthenticationError(
           `Authentication failed: ${errorData}`,
           request.status,
           {
@@ -3186,7 +2981,7 @@ var uploadJson = async (config, jsonData, network, options) => {
           }
         );
       }
-      throw new NetworkError(`HTTP error: ${errorData}`, request.status, {
+      throw new chunkP556VRQU_js.NetworkError(`HTTP error: ${errorData}`, request.status, {
         error: errorData,
         code: "HTTP_ERROR",
         metadata: {
@@ -3211,7 +3006,7 @@ var uploadJson = async (config, jsonData, network, options) => {
         return resData;
       } else {
         const errorData = await vectorReq.text();
-        throw new NetworkError(
+        throw new chunkP556VRQU_js.NetworkError(
           `HTTP error during vectorization: ${errorData}`,
           vectorReq.status,
           {
@@ -3226,27 +3021,27 @@ var uploadJson = async (config, jsonData, network, options) => {
     }
     return resData;
   } catch (error) {
-    if (error instanceof PinataError) {
+    if (error instanceof chunkP556VRQU_js.PinataError) {
       throw error;
     }
     if (error instanceof Error) {
-      throw new PinataError(`Error processing json: ${error.message}`);
+      throw new chunkP556VRQU_js.PinataError(`Error processing json: ${error.message}`);
     }
-    throw new PinataError("An unknown error occurred while uploading json");
+    throw new chunkP556VRQU_js.PinataError("An unknown error occurred while uploading json");
   }
 };
 
 // src/core/functions/uploads/url.ts
 var uploadUrl = async (config, url, network, options) => {
   if (!config) {
-    throw new ValidationError("Pinata configuration is missing");
+    throw new chunkP556VRQU_js.ValidationError("Pinata configuration is missing");
   }
   const jwt = options?.keys || config?.pinataJwt;
   const data = new FormData();
   const stream = await fetch(url);
   if (!stream.ok) {
     const errorData = await stream.text();
-    throw new NetworkError(`HTTP error: ${errorData}`, stream.status, {
+    throw new chunkP556VRQU_js.NetworkError(`HTTP error: ${errorData}`, stream.status, {
       error: errorData,
       code: "HTTP_ERROR",
       metadata: {
@@ -3292,7 +3087,7 @@ var uploadUrl = async (config, url, network, options) => {
       if (!request.ok) {
         const errorData = await request.text();
         if (request.status === 401 || request.status === 403) {
-          throw new AuthenticationError(
+          throw new chunkP556VRQU_js.AuthenticationError(
             `Authentication failed: ${errorData}`,
             request.status,
             {
@@ -3304,7 +3099,7 @@ var uploadUrl = async (config, url, network, options) => {
             }
           );
         }
-        throw new NetworkError(`HTTP error: ${errorData}`, request.status, {
+        throw new chunkP556VRQU_js.NetworkError(`HTTP error: ${errorData}`, request.status, {
           error: errorData,
           code: "HTTP_ERROR",
           metadata: {
@@ -3316,13 +3111,13 @@ var uploadUrl = async (config, url, network, options) => {
       const resData = res.data;
       return resData;
     } catch (error) {
-      if (error instanceof PinataError) {
+      if (error instanceof chunkP556VRQU_js.PinataError) {
         throw error;
       }
       if (error instanceof Error) {
-        throw new PinataError(`Error processing base64: ${error.message}`);
+        throw new chunkP556VRQU_js.PinataError(`Error processing base64: ${error.message}`);
       }
-      throw new PinataError(
+      throw new chunkP556VRQU_js.PinataError(
         "An unknown error occurred while trying to upload base64"
       );
     }
@@ -3336,7 +3131,7 @@ var uploadUrl = async (config, url, network, options) => {
     if (!request.ok) {
       const errorData = await request.text();
       if (request.status === 401 || request.status === 403) {
-        throw new AuthenticationError(
+        throw new chunkP556VRQU_js.AuthenticationError(
           `Authentication failed: ${errorData}`,
           request.status,
           {
@@ -3348,7 +3143,7 @@ var uploadUrl = async (config, url, network, options) => {
           }
         );
       }
-      throw new NetworkError(`HTTP error: ${errorData}`, request.status, {
+      throw new chunkP556VRQU_js.NetworkError(`HTTP error: ${errorData}`, request.status, {
         error: errorData,
         code: "HTTP_ERROR",
         metadata: {
@@ -3373,7 +3168,7 @@ var uploadUrl = async (config, url, network, options) => {
         return resData;
       } else {
         const errorData = await vectorReq.text();
-        throw new NetworkError(
+        throw new chunkP556VRQU_js.NetworkError(
           `HTTP error during vectorization: ${errorData}`,
           vectorReq.status,
           {
@@ -3388,20 +3183,20 @@ var uploadUrl = async (config, url, network, options) => {
     }
     return resData;
   } catch (error) {
-    if (error instanceof PinataError) {
+    if (error instanceof chunkP556VRQU_js.PinataError) {
       throw error;
     }
     if (error instanceof Error) {
-      throw new PinataError(`Error processing url: ${error.message}`);
+      throw new chunkP556VRQU_js.PinataError(`Error processing url: ${error.message}`);
     }
-    throw new PinataError("An unknown error occurred while uploading by url");
+    throw new chunkP556VRQU_js.PinataError("An unknown error occurred while uploading by url");
   }
 };
 
 // src/core/functions/uploads/cid.ts
 var uploadCid = async (config, cid, options) => {
   if (!config) {
-    throw new ValidationError("Pinata configuration is missing");
+    throw new chunkP556VRQU_js.ValidationError("Pinata configuration is missing");
   }
   const jwt = options?.keys || config?.pinataJwt;
   let headers;
@@ -3439,7 +3234,7 @@ var uploadCid = async (config, cid, options) => {
     if (!request.ok) {
       const errorData = await request.text();
       if (request.status === 401 || request.status === 403) {
-        throw new AuthenticationError(
+        throw new chunkP556VRQU_js.AuthenticationError(
           `Authentication failed: ${errorData}`,
           request.status,
           {
@@ -3451,7 +3246,7 @@ var uploadCid = async (config, cid, options) => {
           }
         );
       }
-      throw new NetworkError(`HTTP error: ${errorData}`, request.status, {
+      throw new chunkP556VRQU_js.NetworkError(`HTTP error: ${errorData}`, request.status, {
         error: errorData,
         code: "HTTP_ERROR",
         metadata: {
@@ -3463,32 +3258,20 @@ var uploadCid = async (config, cid, options) => {
     const resData = res.data;
     return resData;
   } catch (error) {
-    if (error instanceof PinataError) {
+    if (error instanceof chunkP556VRQU_js.PinataError) {
       throw error;
     }
     if (error instanceof Error) {
-      throw new PinataError(`Error processing cid: ${error.message}`);
+      throw new chunkP556VRQU_js.PinataError(`Error processing cid: ${error.message}`);
     }
-    throw new PinataError("An unknown error occurred while pinning by CID");
+    throw new chunkP556VRQU_js.PinataError("An unknown error occurred while pinning by CID");
   }
 };
 
-// src/utils/format-config.ts
-var formatConfig = (config) => {
-  let gateway = config?.pinataGateway;
-  if (config && gateway) {
-    if (gateway && !gateway.startsWith("https://")) {
-      gateway = `https://${gateway}`;
-    }
-    config.pinataGateway = gateway;
-  }
-  return config;
-};
-
 // src/core/classes/analytics/Analytics.ts
 var Analytics = class {
   constructor(config) {
-    this.config = formatConfig(config);
+    this.config = chunkP556VRQU_js.formatConfig(config);
     this.requests = new AnalyticsRequests(this.config);
     this.bandwidth = new AnalyticsBandwidth(this.config);
   }
@@ -3791,7 +3574,7 @@ var FilterGroups = class {
 // src/core/classes/groups/PublicGroups.ts
 var PublicGroups = class {
   constructor(config) {
-    this.config = formatConfig(config);
+    this.config = chunkP556VRQU_js.formatConfig(config);
   }
   updateConfig(newConfig) {
     this.config = newConfig;
@@ -3822,7 +3605,7 @@ var PublicGroups = class {
 // src/core/classes/groups/PrivateGroups.ts
 var PrivateGroups = class {
   constructor(config) {
-    this.config = formatConfig(config);
+    this.config = chunkP556VRQU_js.formatConfig(config);
   }
   updateConfig(newConfig) {
     this.config = newConfig;
@@ -3853,7 +3636,7 @@ var PrivateGroups = class {
 // src/core/classes/groups/Groups.ts
 var Groups = class {
   constructor(config) {
-    this.config = formatConfig(config);
+    this.config = chunkP556VRQU_js.formatConfig(config);
     this.public = new PublicGroups(config);
     this.private = new PrivateGroups(config);
   }
@@ -3865,7 +3648,7 @@ var Groups = class {
 // src/core/classes/keys/Keys.ts
 var Keys = class {
   constructor(config) {
-    this.config = formatConfig(config);
+    this.config = chunkP556VRQU_js.formatConfig(config);
   }
   updateConfig(newConfig) {
     this.config = newConfig;
@@ -3956,7 +3739,7 @@ var FilterKeys = class {
 // src/core/classes/gateways/Gateways.ts
 var Gateways = class {
   constructor(config) {
-    this.config = formatConfig(config);
+    this.config = chunkP556VRQU_js.formatConfig(config);
     this.public = new PublicGateways(config);
     this.private = new PrivateGateways(config);
   }
@@ -4031,7 +3814,7 @@ var PublicGateways = class {
 // src/core/functions/files/getFile.ts
 var getFile = async (config, id, privacy) => {
   if (!config) {
-    throw new ValidationError("Pinata configuration is missing");
+    throw new chunkP556VRQU_js.ValidationError("Pinata configuration is missing");
   }
   let headers;
   if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
@@ -4059,7 +3842,7 @@ var getFile = async (config, id, privacy) => {
     if (!request.ok) {
       const errorData = await request.text();
       if (request.status === 401 || request.status === 403) {
-        throw new AuthenticationError(
+        throw new chunkP556VRQU_js.AuthenticationError(
           `Authentication failed: ${errorData}`,
           request.status,
           {
@@ -4071,7 +3854,7 @@ var getFile = async (config, id, privacy) => {
           }
         );
       }
-      throw new NetworkError(`HTTP error: ${errorData}`, request.status, {
+      throw new chunkP556VRQU_js.NetworkError(`HTTP error: ${errorData}`, request.status, {
         error: errorData,
         code: "HTTP_ERROR",
         metadata: {
@@ -4083,13 +3866,13 @@ var getFile = async (config, id, privacy) => {
     const resData = res.data;
     return resData;
   } catch (error) {
-    if (error instanceof PinataError) {
+    if (error instanceof chunkP556VRQU_js.PinataError) {
       throw error;
     }
     if (error instanceof Error) {
-      throw new PinataError(`Error processing getGroup: ${error.message}`);
+      throw new chunkP556VRQU_js.PinataError(`Error processing getGroup: ${error.message}`);
     }
-    throw new PinataError(
+    throw new chunkP556VRQU_js.PinataError(
       "An unknown error occurred while getting info for a group"
     );
   }
@@ -4271,7 +4054,7 @@ var FilterQueue = class {
 // src/core/classes/files/PublicFiles.ts
 var PublicFiles = class {
   constructor(config) {
-    this.config = formatConfig(config);
+    this.config = chunkP556VRQU_js.formatConfig(config);
   }
   list() {
     return new FilterFiles(this.config, "public");
@@ -4305,7 +4088,7 @@ var PublicFiles = class {
 // src/core/classes/files/PrivateFiles.ts
 var PrivateFiles = class {
   constructor(config) {
-    this.config = formatConfig(config);
+    this.config = chunkP556VRQU_js.formatConfig(config);
   }
   list() {
     return new FilterFiles(this.config, "private");
@@ -4342,7 +4125,7 @@ var PrivateFiles = class {
 // src/core/classes/files/Files.ts
 var Files = class {
   constructor(config) {
-    this.config = formatConfig(config);
+    this.config = chunkP556VRQU_js.formatConfig(config);
     this.public = new PublicFiles(config);
     this.private = new PrivateFiles(config);
   }
@@ -4436,7 +4219,7 @@ var UploadBuilder = class {
 // src/core/classes/uploads/PublicUpload.ts
 var PublicUpload = class {
   constructor(config) {
-    this.config = formatConfig(config);
+    this.config = chunkP556VRQU_js.formatConfig(config);
   }
   updateConfig(newConfig) {
     this.config = newConfig;
@@ -4497,7 +4280,7 @@ var PublicUpload = class {
 // src/core/classes/uploads/PrivateUpload.ts
 var PrivateUpload = class {
   constructor(config) {
-    this.config = formatConfig(config);
+    this.config = chunkP556VRQU_js.formatConfig(config);
   }
   updateConfig(newConfig) {
     this.config = newConfig;
@@ -4555,7 +4338,7 @@ var PrivateUpload = class {
 // src/core/classes/uploads/Upload.ts
 var Upload = class {
   constructor(config) {
-    this.config = formatConfig(config);
+    this.config = chunkP556VRQU_js.formatConfig(config);
     this.public = new PublicUpload(config);
     this.private = new PrivateUpload(config);
   }
@@ -4567,7 +4350,7 @@ var Upload = class {
 // src/core/functions/signatures/addSignature.ts
 var addSignature = async (config, options, network) => {
   if (!config) {
-    throw new ValidationError("Pinata configuration is missing");
+    throw new chunkP556VRQU_js.ValidationError("Pinata configuration is missing");
   }
   const data = JSON.stringify({
     signature: options.signature,
@@ -4599,7 +4382,7 @@ var addSignature = async (config, options, network) => {
     if (!request.ok) {
       const errorData = await request.text();
       if (request.status === 401 || request.status === 403) {
-        throw new AuthenticationError(
+        throw new chunkP556VRQU_js.AuthenticationError(
           `Authentication failed: ${errorData}`,
           request.status,
           {
@@ -4612,7 +4395,7 @@ var addSignature = async (config, options, network) => {
         );
       }
       if (request.status === 403) {
-        throw new PinataError(
+        throw new chunkP556VRQU_js.PinataError(
           "Unauthorized signing, you must be the original owner of the file and it must not have a signature",
           request.status,
           {
@@ -4624,7 +4407,7 @@ var addSignature = async (config, options, network) => {
           }
         );
       }
-      throw new NetworkError(`HTTP error: ${errorData}`, request.status, {
+      throw new chunkP556VRQU_js.NetworkError(`HTTP error: ${errorData}`, request.status, {
         error: errorData,
         code: "HTTP_ERROR",
         metadata: {
@@ -4635,13 +4418,13 @@ var addSignature = async (config, options, network) => {
     const res = await request.json();
     return res.data;
   } catch (error) {
-    if (error instanceof PinataError) {
+    if (error instanceof chunkP556VRQU_js.PinataError) {
       throw error;
     }
     if (error instanceof Error) {
-      throw new PinataError(`Error processing addSignature: ${error.message}`);
+      throw new chunkP556VRQU_js.PinataError(`Error processing addSignature: ${error.message}`);
     }
-    throw new PinataError(
+    throw new chunkP556VRQU_js.PinataError(
       "An unknown error occurred while adding signature to CID"
     );
   }
@@ -4650,7 +4433,7 @@ var addSignature = async (config, options, network) => {
 // src/core/functions/signatures/getSignature.ts
 var getSignature = async (config, cid, network) => {
   if (!config) {
-    throw new ValidationError("Pinata configuration is missing");
+    throw new chunkP556VRQU_js.ValidationError("Pinata configuration is missing");
   }
   let headers;
   if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
@@ -4677,7 +4460,7 @@ var getSignature = async (config, cid, network) => {
     if (!request.ok) {
       const errorData = await request.text();
       if (request.status === 401 || request.status === 403) {
-        throw new AuthenticationError(
+        throw new chunkP556VRQU_js.AuthenticationError(
           `Authentication failed: ${errorData}`,
           request.status,
           {
@@ -4689,7 +4472,7 @@ var getSignature = async (config, cid, network) => {
           }
         );
       }
-      throw new NetworkError(`HTTP error: ${errorData}`, request.status, {
+      throw new chunkP556VRQU_js.NetworkError(`HTTP error: ${errorData}`, request.status, {
         error: errorData,
         code: "HTTP_ERROR",
         metadata: {
@@ -4700,13 +4483,13 @@ var getSignature = async (config, cid, network) => {
     const res = await request.json();
     return res.data;
   } catch (error) {
-    if (error instanceof PinataError) {
+    if (error instanceof chunkP556VRQU_js.PinataError) {
       throw error;
     }
     if (error instanceof Error) {
-      throw new PinataError(`Error processing getSignature: ${error.message}`);
+      throw new chunkP556VRQU_js.PinataError(`Error processing getSignature: ${error.message}`);
     }
-    throw new PinataError(
+    throw new chunkP556VRQU_js.PinataError(
       "An unknown error occurred while fetching signature for CID"
     );
   }
@@ -4715,7 +4498,7 @@ var getSignature = async (config, cid, network) => {
 // src/core/functions/signatures/removeSignature.ts
 var removeSignature = async (config, cid, network) => {
   if (!config) {
-    throw new ValidationError("Pinata configuration is missing");
+    throw new chunkP556VRQU_js.ValidationError("Pinata configuration is missing");
   }
   let headers;
   if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
@@ -4742,7 +4525,7 @@ var removeSignature = async (config, cid, network) => {
     if (!request.ok) {
       const errorData = await request.text();
       if (request.status === 401 || request.status === 403) {
-        throw new AuthenticationError(
+        throw new chunkP556VRQU_js.AuthenticationError(
           `Authentication failed: ${errorData}`,
           request.status,
           {
@@ -4754,7 +4537,7 @@ var removeSignature = async (config, cid, network) => {
           }
         );
       }
-      throw new NetworkError(`HTTP error: ${errorData}`, request.status, {
+      throw new chunkP556VRQU_js.NetworkError(`HTTP error: ${errorData}`, request.status, {
         error: errorData,
         code: "HTTP_ERROR",
         metadata: {
@@ -4764,13 +4547,13 @@ var removeSignature = async (config, cid, network) => {
     }
     return "OK";
   } catch (error) {
-    if (error instanceof PinataError) {
+    if (error instanceof chunkP556VRQU_js.PinataError) {
       throw error;
     }
     if (error instanceof Error) {
-      throw new PinataError(`Error processing addSignature: ${error.message}`);
+      throw new chunkP556VRQU_js.PinataError(`Error processing addSignature: ${error.message}`);
     }
-    throw new PinataError(
+    throw new chunkP556VRQU_js.PinataError(
       "An unknown error occurred while adding signature to CID"
     );
   }
@@ -4779,7 +4562,7 @@ var removeSignature = async (config, cid, network) => {
 // src/core/classes/signatures/PublicSignatures.ts
 var PublicSignatures = class {
   constructor(config) {
-    this.config = formatConfig(config);
+    this.config = chunkP556VRQU_js.formatConfig(config);
   }
   updateConfig(newConfig) {
     this.config = newConfig;
@@ -4799,7 +4582,7 @@ var PublicSignatures = class {
 var Signatures = class {
   //private: PrivateSignatures
   constructor(config) {
-    this.config = formatConfig(config);
+    this.config = chunkP556VRQU_js.formatConfig(config);
     this.public = new PublicSignatures(config);
   }
   updateConfig(newConfig) {
@@ -4810,7 +4593,7 @@ var Signatures = class {
 // src/core/pinataSDK.ts
 var PinataSDK = class {
   constructor(config) {
-    this.config = formatConfig(config);
+    this.config = chunkP556VRQU_js.formatConfig(config);
     this.files = new Files(this.config);
     this.upload = new Upload(this.config);
     this.gateways = new Gateways(this.config);
@@ -4849,52 +4632,83 @@ var PinataSDK = class {
     return testAuthentication(this.config);
   }
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  AuthenticationError,
-  NetworkError,
-  PinataError,
-  PinataSDK,
-  ValidationError,
-  addToGroup,
-  analyticsDateInterval,
-  analyticsTopUsage,
-  containsCID,
-  convertIPFSUrl,
-  convertToDesiredGateway,
-  createAccessLink,
-  createGroup,
-  createKey,
-  createSignedUploadURL,
-  deleteFile,
-  deleteFileVectors,
-  deleteGroup,
-  deletePinRequest,
-  deleteSwap,
-  formatConfig,
-  getCid,
-  getFileIdFromUrl,
-  getGroup,
-  listFiles,
-  listGroups,
-  listKeys,
-  pinnedFileCount,
-  queue,
-  removeFromGroup,
-  revokeKeys,
-  swapCid,
-  swapHistory,
-  testAuthentication,
-  totalStorageUsage,
-  updateFile,
-  updateGroup,
-  uploadBase64,
-  uploadCid,
-  uploadFile,
-  uploadFileArray,
-  uploadJson,
-  uploadUrl,
-  vectorizeFile,
-  vectorizeQuery
+
+Object.defineProperty(exports, "AuthenticationError", {
+  enumerable: true,
+  get: function () { return chunkP556VRQU_js.AuthenticationError; }
+});
+Object.defineProperty(exports, "NetworkError", {
+  enumerable: true,
+  get: function () { return chunkP556VRQU_js.NetworkError; }
+});
+Object.defineProperty(exports, "PinataError", {
+  enumerable: true,
+  get: function () { return chunkP556VRQU_js.PinataError; }
+});
+Object.defineProperty(exports, "ValidationError", {
+  enumerable: true,
+  get: function () { return chunkP556VRQU_js.ValidationError; }
+});
+Object.defineProperty(exports, "containsCID", {
+  enumerable: true,
+  get: function () { return chunkP556VRQU_js.containsCID; }
+});
+Object.defineProperty(exports, "convert", {
+  enumerable: true,
+  get: function () { return chunkP556VRQU_js.convertToDesiredGateway; }
+});
+Object.defineProperty(exports, "convertToDesiredGateway", {
+  enumerable: true,
+  get: function () { return chunkP556VRQU_js.convertToDesiredGateway; }
+});
+Object.defineProperty(exports, "formatConfig", {
+  enumerable: true,
+  get: function () { return chunkP556VRQU_js.formatConfig; }
+});
+Object.defineProperty(exports, "getFileIdFromUrl", {
+  enumerable: true,
+  get: function () { return chunkP556VRQU_js.getFileIdFromUrl; }
+});
+Object.defineProperty(exports, "useUpload", {
+  enumerable: true,
+  get: function () { return chunkP556VRQU_js.useUpload; }
 });
+exports.PinataSDK = PinataSDK;
+exports.addToGroup = addToGroup;
+exports.analyticsDateInterval = analyticsDateInterval;
+exports.analyticsTopUsage = analyticsTopUsage;
+exports.convertIPFSUrl = convertIPFSUrl;
+exports.createAccessLink = createAccessLink;
+exports.createGroup = createGroup;
+exports.createKey = createKey;
+exports.createSignedUploadURL = createSignedUploadURL;
+exports.deleteFile = deleteFile;
+exports.deleteFileVectors = deleteFileVectors;
+exports.deleteGroup = deleteGroup;
+exports.deletePinRequest = deletePinRequest;
+exports.deleteSwap = deleteSwap;
+exports.getCid = getCid;
+exports.getGroup = getGroup;
+exports.listFiles = listFiles;
+exports.listGroups = listGroups;
+exports.listKeys = listKeys;
+exports.pinnedFileCount = pinnedFileCount;
+exports.queue = queue;
+exports.removeFromGroup = removeFromGroup;
+exports.revokeKeys = revokeKeys;
+exports.swapCid = swapCid;
+exports.swapHistory = swapHistory;
+exports.testAuthentication = testAuthentication;
+exports.totalStorageUsage = totalStorageUsage;
+exports.updateFile = updateFile;
+exports.updateGroup = updateGroup;
+exports.uploadBase64 = uploadBase64;
+exports.uploadCid = uploadCid;
+exports.uploadFile = uploadFile;
+exports.uploadFileArray = uploadFileArray;
+exports.uploadJson = uploadJson;
+exports.uploadUrl = uploadUrl;
+exports.vectorizeFile = vectorizeFile;
+exports.vectorizeQuery = vectorizeQuery;
+//# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map