pinata 0.3.4 → 1.0.0

package/dist/index.js

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,14 +15,6 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -117,7 +107,7 @@ var testAuthentication = async (config) => {
   }
 };
 
-// src/core/pinning/file.ts
+// src/core/uploads/file.ts
 var uploadFile = async (config, file, options) => {
   if (!config) {
     throw new ValidationError("Pinata configuration is missing");
@@ -125,20 +115,10 @@ var uploadFile = async (config, file, options) => {
   const jwt = options?.keys || config.pinataJwt;
   const data = new FormData();
   data.append("file", file, file.name);
-  data.append(
-    "pinataOptions",
-    JSON.stringify({
-      cidVersion: options?.cidVersion,
-      groupId: options?.groupId
-    })
-  );
-  data.append(
-    "pinataMetadata",
-    JSON.stringify({
-      name: options?.metadata?.name || file.name || "File from SDK",
-      keyvalues: options?.metadata?.keyValues
-    })
-  );
+  data.append("name", options?.metadata?.name || file.name || "File from SDK");
+  if (options?.groupId) {
+    data.append("group_id", options.groupId);
+  }
   let headers;
   if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
     headers = { ...config.customHeaders };
@@ -148,12 +128,12 @@ var uploadFile = async (config, file, options) => {
       Source: "sdk/file"
     };
   }
-  let endpoint = "https://api.pinata.cloud";
+  let endpoint = "https://uploads.pinata.cloud/v3";
   if (config.endpointUrl) {
     endpoint = config.endpointUrl;
   }
   try {
-    const request = await fetch(`${endpoint}/pinning/pinFileToIPFS`, {
+    const request = await fetch(`${endpoint}/files`, {
       method: "POST",
       headers,
       body: data
@@ -186,81 +166,7 @@ var uploadFile = async (config, file, options) => {
   }
 };
 
-// src/core/pinning/fileArray.ts
-var uploadFileArray = async (config, files, options) => {
-  if (!config) {
-    throw new ValidationError("Pinata configuration is missing");
-  }
-  const jwt = options?.keys || config?.pinataJwt;
-  const folder = options?.metadata?.name || "folder_from_sdk";
-  const data = new FormData();
-  for (const file of Array.from(files)) {
-    data.append("file", file, `${folder}/${file.name}`);
-  }
-  data.append(
-    "pinataMetadata",
-    JSON.stringify({
-      name: folder,
-      keyvalues: options?.metadata?.keyValues
-    })
-  );
-  data.append(
-    "pinataOptions",
-    JSON.stringify({
-      cidVersion: options?.cidVersion,
-      groupId: options?.groupId
-    })
-  );
-  let headers;
-  if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
-    headers = { ...config.customHeaders };
-  } else {
-    headers = {
-      Authorization: `Bearer ${jwt}`,
-      Source: "sdk/fileArray"
-    };
-  }
-  let endpoint = "https://api.pinata.cloud";
-  if (config.endpointUrl) {
-    endpoint = config.endpointUrl;
-  }
-  try {
-    const request = await fetch(`${endpoint}/pinning/pinFileToIPFS`, {
-      method: "POST",
-      headers,
-      body: data
-    });
-    if (!request.ok) {
-      const errorData = await request.text();
-      if (request.status === 401 || request.status === 403) {
-        throw new AuthenticationError(
-          `Authentication failed: ${errorData}`,
-          request.status,
-          errorData
-        );
-      }
-      throw new NetworkError(
-        `HTTP error: ${errorData}`,
-        request.status,
-        errorData
-      );
-    }
-    const res = await request.json();
-    return res;
-  } catch (error) {
-    if (error instanceof PinataError) {
-      throw error;
-    }
-    if (error instanceof Error) {
-      throw new PinataError(`Error processing fileArray: ${error.message}`);
-    }
-    throw new PinataError(
-      "An unknown error occurred while uploading an array of files"
-    );
-  }
-};
-
-// src/core/pinning/base64.ts
+// src/core/uploads/base64.ts
 var uploadBase64 = async (config, base64String, options) => {
   if (!config) {
     throw new ValidationError("Pinata configuration is missing");
@@ -271,20 +177,10 @@ var uploadBase64 = async (config, base64String, options) => {
   const blob = new Blob([buffer]);
   const data = new FormData();
   data.append("file", blob, name);
-  data.append(
-    "pinataOptions",
-    JSON.stringify({
-      cidVersion: options?.cidVersion,
-      groupId: options?.groupId
-    })
-  );
-  data.append(
-    "pinataMetadata",
-    JSON.stringify({
-      name,
-      keyvalues: options?.metadata?.keyValues
-    })
-  );
+  data.append("name", name);
+  if (options?.groupId) {
+    data.append("group_id", options.groupId);
+  }
   let headers;
   if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
     headers = { ...config.customHeaders };
@@ -294,12 +190,12 @@ var uploadBase64 = async (config, base64String, options) => {
       Source: "sdk/base64"
     };
   }
-  let endpoint = "https://api.pinata.cloud";
+  let endpoint = "https://uploads.pinata.cloud/v3";
   if (config.endpointUrl) {
     endpoint = config.endpointUrl;
   }
   try {
-    const request = await fetch(`${endpoint}/pinning/pinFileToIPFS`, {
+    const request = await fetch(`${endpoint}/files`, {
       method: "POST",
       headers,
       body: data
@@ -334,7 +230,7 @@ var uploadBase64 = async (config, base64String, options) => {
   }
 };
 
-// src/core/pinning/url.ts
+// src/core/uploads/url.ts
 var uploadUrl = async (config, url, options) => {
   if (!config) {
     throw new ValidationError("Pinata configuration is missing");
@@ -355,20 +251,10 @@ var uploadUrl = async (config, url, options) => {
   const name = options?.metadata?.name ?? "url_upload";
   const file = new File([blob], name);
   data.append("file", file, name);
-  data.append(
-    "pinataOptions",
-    JSON.stringify({
-      cidVersion: options?.cidVersion,
-      groupId: options?.groupId
-    })
-  );
-  data.append(
-    "pinataMetadata",
-    JSON.stringify({
-      name,
-      keyvalues: options?.metadata?.keyValues
-    })
-  );
+  data.append("name", name);
+  if (options?.groupId) {
+    data.append("group_id", options.groupId);
+  }
   let headers;
   if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
     headers = { ...config.customHeaders };
@@ -378,12 +264,12 @@ var uploadUrl = async (config, url, options) => {
       Source: "sdk/url"
     };
   }
-  let endpoint = "https://api.pinata.cloud";
+  let endpoint = "https://uploads.pinata.cloud/v3";
   if (config.endpointUrl) {
     endpoint = config.endpointUrl;
   }
   try {
-    const request = await fetch(`${endpoint}/pinning/pinFileToIPFS`, {
+    const request = await fetch(`${endpoint}/files`, {
       method: "POST",
       headers,
       body: data
@@ -416,39 +302,36 @@ var uploadUrl = async (config, url, options) => {
   }
 };
 
-// src/core/pinning/json.ts
+// src/core/uploads/json.ts
 var uploadJson = async (config, jsonData, options) => {
   if (!config) {
     throw new ValidationError("Pinata configuration is missing");
   }
   const jwt = options?.keys || config?.pinataJwt;
-  const data = JSON.stringify({
-    pinataContent: jsonData,
-    pinataOptions: {
-      cidVersion: options?.cidVersion,
-      groupId: options?.groupId
-    },
-    pinataMetadata: {
-      name: options?.metadata?.name || "json",
-      keyvalues: options?.metadata?.keyValues
-    }
-  });
+  const json = JSON.stringify(jsonData);
+  const blob = new Blob([json]);
+  const file = new File([blob], "data.json", { type: "application/json" });
+  const data = new FormData();
+  data.append("file", file, file.name);
+  data.append("name", options?.metadata?.name || file.name || "File from SDK");
+  if (options?.groupId) {
+    data.append("group_id", options.groupId);
+  }
   let headers;
   if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
     headers = { ...config.customHeaders };
   } else {
     headers = {
       Authorization: `Bearer ${jwt}`,
-      "Content-Type": "application/json",
       Source: "sdk/json"
     };
   }
-  let endpoint = "https://api.pinata.cloud";
+  let endpoint = "https://uploads.pinata.cloud/v3";
   if (config.endpointUrl) {
     endpoint = config.endpointUrl;
   }
   try {
-    const request = await fetch(`${endpoint}/pinning/pinJSONToIPFS`, {
+    const request = await fetch(`${endpoint}/files`, {
       method: "POST",
       headers,
       body: data
@@ -481,78 +364,13 @@ var uploadJson = async (config, jsonData, options) => {
   }
 };
 
-// src/core/pinning/cid.ts
-var uploadCid = async (config, cid, options) => {
-  if (!config) {
-    throw new ValidationError("Pinata configuration is missing");
-  }
-  const jwt = options?.keys || config?.pinataJwt;
-  let headers;
-  if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
-    headers = { ...config.customHeaders };
-  } else {
-    headers = {
-      Authorization: `Bearer ${jwt}`,
-      "Content-Type": "application/json",
-      Source: "sdk/cid"
-    };
-  }
-  const data = JSON.stringify({
-    hashToPin: cid,
-    pinataMetadata: {
-      name: options?.metadata ? options?.metadata?.name : cid,
-      keyvalues: options?.metadata?.keyValues
-    },
-    pinataOptions: {
-      hostNodes: options?.peerAddresses ? options.peerAddresses : "",
-      groupId: options?.groupId
-    }
-  });
-  let endpoint = "https://api.pinata.cloud";
-  if (config.endpointUrl) {
-    endpoint = config.endpointUrl;
-  }
-  try {
-    const request = await fetch(`${endpoint}/pinning/pinByHash`, {
-      method: "POST",
-      headers,
-      body: data
-    });
-    if (!request.ok) {
-      const errorData = await request.text();
-      if (request.status === 401 || request.status === 403) {
-        throw new AuthenticationError(
-          `Authentication failed: ${errorData}`,
-          request.status,
-          errorData
-        );
-      }
-      throw new NetworkError(
-        `HTTP error: ${errorData}`,
-        request.status,
-        errorData
-      );
-    }
-    const res = await request.json();
-    return res;
-  } catch (error) {
-    if (error instanceof PinataError) {
-      throw error;
-    }
-    if (error instanceof Error) {
-      throw new PinataError(`Error processing cid: ${error.message}`);
-    }
-    throw new PinataError("An unknown error occurred while pinning by CID");
-  }
-};
-
-// src/core/pinning/unpin.ts
+// src/core/files/delete.ts
 var wait = (milliseconds) => {
   return new Promise((resolve) => {
     setTimeout(resolve, milliseconds);
   });
 };
-var unpinFile = async (config, files) => {
+var deleteFile = async (config, files) => {
   if (!config) {
     throw new ValidationError("Pinata configuration is missing");
   }
@@ -566,13 +384,13 @@ var unpinFile = async (config, files) => {
       Source: "sdk/unpin"
     };
   }
-  let endpoint = "https://api.pinata.cloud";
+  let endpoint = "https://api.pinata.cloud/v3";
   if (config.endpointUrl) {
     endpoint = config.endpointUrl;
   }
-  for (const hash of files) {
+  for (const id of files) {
     try {
-      const response = await fetch(`${endpoint}/pinning/unpin/${hash}`, {
+      const response = await fetch(`${endpoint}/files/${id}`, {
         method: "DELETE",
         headers
       });
@@ -592,22 +410,21 @@ var unpinFile = async (config, files) => {
           errorData
         );
       }
-      const result = await response.text();
       responses.push({
-        hash,
-        status: result
+        id,
+        status: response.statusText
       });
     } catch (error) {
       let errorMessage;
       if (error instanceof PinataError) {
         errorMessage = error.message;
       } else if (error instanceof Error) {
-        errorMessage = `Error unpinning file ${hash}: ${error.message}`;
+        errorMessage = `Error deleting file ${id}: ${error.message}`;
       } else {
-        errorMessage = `An unknown error occurred while unpinning file ${hash}`;
+        errorMessage = `An unknown error occurred while deleting file ${id}`;
       }
       responses.push({
-        hash,
+        id,
         status: errorMessage
       });
     }
@@ -615,59 +432,26 @@ var unpinFile = async (config, files) => {
   return responses;
 };
 
-// src/core/data/listFiles.ts
+// src/core/files/list.ts
 var listFiles = async (config, options) => {
   if (!config) {
     throw new ValidationError("Pinata configuration is missing");
   }
-  const params = new URLSearchParams({
-    includesCount: "false"
-  });
+  const params = new URLSearchParams();
   if (options) {
-    const {
-      cid,
-      pinStart,
-      pinEnd,
-      pinSizeMin,
-      pinSizeMax,
-      pageLimit,
-      pageOffset,
-      name,
-      key,
-      value,
-      operator,
-      groupId
-    } = options;
-    if (cid)
-      params.append("cid", cid);
-    if (pinStart)
-      params.append("pinStart", pinStart);
-    if (pinEnd)
-      params.append("pinEnd", pinEnd);
-    if (pinSizeMin)
-      params.append("pinSizeMin", pinSizeMin.toString());
-    if (pinSizeMax)
-      params.append("pinSizeMax", pinSizeMax.toString());
-    if (pageLimit)
-      params.append("pageLimit", pageLimit.toString());
-    if (pageOffset)
-      params.append("pageOffset", pageOffset.toString());
-    if (groupId)
-      params.append("groupId", groupId);
-    if (name)
-      params.append("metadata[name]", name);
-    if (key && value) {
-      const keyValueParam = JSON.stringify({
-        [key]: { value, op: operator || "eq" }
-      });
-      params.append("metadata[keyvalues]", keyValueParam);
-    }
+    const { limit, pageToken, cidPending } = options;
+    if (limit)
+      params.append("limit", limit.toString());
+    if (pageToken)
+      params.append("pageToken", pageToken);
+    if (cidPending)
+      params.append("cidPending", "true");
   }
-  let endpoint = "https://api.pinata.cloud";
+  let endpoint = "https://api.pinata.cloud/v3";
   if (config.endpointUrl) {
     endpoint = config.endpointUrl;
   }
-  const url = `${endpoint}/data/pinList?status=pinned&${params.toString()}`;
+  const url = `${endpoint}/files?${params.toString()}`;
   try {
     let headers;
     if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
@@ -698,7 +482,8 @@ var listFiles = async (config, options) => {
       );
     }
     const res = await request.json();
-    return res.rows;
+    const resData = res.data;
+    return resData;
   } catch (error) {
     if (error instanceof PinataError) {
       throw error;
@@ -710,16 +495,14 @@ var listFiles = async (config, options) => {
   }
 };
 
-// src/core/data/updateMetadata.ts
-var updateMetadata = async (config, options) => {
+// src/core/files/updateFile.ts
+var updateFile = async (config, options) => {
   if (!config) {
     throw new ValidationError("Pinata configuration is missing");
   }
-  const data = {
-    ipfsPinHash: options.cid,
-    name: options.name,
-    keyvalues: options.keyValues
-  };
+  const data = JSON.stringify({
+    name: options.name
+  });
   let headers;
   if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
     headers = { ...config.customHeaders };
@@ -730,15 +513,15 @@ var updateMetadata = async (config, options) => {
       Source: "sdk/updateMetadata"
     };
   }
-  let endpoint = "https://api.pinata.cloud";
+  let endpoint = "https://api.pinata.cloud/v3";
   if (config.endpointUrl) {
     endpoint = config.endpointUrl;
   }
   try {
-    const request = await fetch(`${endpoint}/pinning/hashMetadata`, {
+    const request = await fetch(`${endpoint}/files/${options.id}`, {
       method: "PUT",
       headers,
-      body: JSON.stringify(data)
+      body: data
     });
     if (!request.ok) {
       const errorData = await request.text();
@@ -755,128 +538,49 @@ var updateMetadata = async (config, options) => {
         errorData
       );
     }
-    const res = await request.text();
-    return res;
+    const res = await request.json();
+    const resData = res.data;
+    return resData;
   } catch (error) {
     if (error instanceof PinataError) {
       throw error;
     }
     if (error instanceof Error) {
-      throw new PinataError(
-        `Error processing updateMetadata: ${error.message}`
-      );
+      throw new PinataError(`Error processing updateFile: ${error.message}`);
     }
-    throw new PinataError("An unknown error occurred while updating metadata");
+    throw new PinataError("An unknown error occurred while updating file");
   }
 };
 
-// src/utils/gateway-tools.ts
-var isIPFSModule;
-async function getIsIPFS() {
-  if (!isIPFSModule) {
-    isIPFSModule = await import("is-ipfs");
-  }
-  return isIPFSModule;
-}
-async function containsCID(input) {
-  if (typeof input !== "string") {
-    throw new Error("Input is not a string");
-  }
-  const isIPFS = await getIsIPFS();
-  const startsWithCID = (str) => {
-    const parts = str.split("/");
-    return isIPFS.cid(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 (isIPFS.cid(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/gateway/getCid.ts
 var getCid = async (config, cid) => {
   if (!config) {
     throw new ValidationError("Pinata configuration is missing");
   }
   let data;
-  let newUrl;
-  newUrl = await convertToDesiredGateway(cid, config?.pinataGateway);
-  if (config?.pinataGatewayKey) {
-    newUrl = `${newUrl}?pinataGatewayToken=${config?.pinataGatewayKey}`;
-  }
+  let newUrl = `${config?.pinataGateway}/files/${cid}`;
+  const params = new URLSearchParams();
+  const date = Math.floor((/* @__PURE__ */ new Date()).getTime() / 1e3);
+  const payload = JSON.stringify({
+    url: newUrl,
+    date,
+    expires: 30,
+    method: "GET"
+  });
+  const signedUrlRequest = await fetch(
+    "https://api.pinata.cloud/v3/files/sign",
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${config?.pinataJwt}`
+      },
+      body: payload
+    }
+  );
+  const signedUrl = await signedUrlRequest.json();
   try {
-    const request = await fetch(newUrl);
+    const request = await fetch(signedUrl.data);
     if (!request.ok) {
       const errorData = await request.text();
       if (request.status === 401 || request.status === 403) {
@@ -918,55 +622,31 @@ var getCid = async (config, cid) => {
   }
 };
 
-// src/core/gateway/convertIPFSUrl.ts
-var convertIPFSUrl = async (config, url) => {
-  let newUrl;
-  newUrl = await convertToDesiredGateway(url, config?.pinataGateway);
-  if (config?.pinataGatewayKey) {
-    `${newUrl}?pinataGatewayToken=${config?.pinataGatewayKey}`;
-  }
-  return newUrl;
-};
-
-// src/core/data/pinJobs.ts
-var pinJobs = async (config, options) => {
+// src/core/keys/createKey.ts
+var createKey = async (config, options) => {
   if (!config) {
     throw new ValidationError("Pinata configuration is missing");
   }
-  const params = new URLSearchParams({
-    includesCount: "false"
-  });
-  if (options) {
-    const { ipfs_pin_hash: cid, status, sort, limit, offset } = options;
-    if (cid)
-      params.append("ipfs_pin_hash", cid.toString());
-    if (status)
-      params.append("status", status.toString());
-    if (sort)
-      params.append("sort", sort.toString());
-    if (limit)
-      params.append("limit", limit.toString());
-    if (offset)
-      params.append("offset", offset.toString());
-  }
-  let endpoint = "https://api.pinata.cloud";
-  if (config.endpointUrl) {
-    endpoint = config.endpointUrl;
-  }
-  const url = `${endpoint}/pinning/pinJobs?${params.toString()}`;
   let headers;
   if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
     headers = { ...config.customHeaders };
   } else {
     headers = {
       Authorization: `Bearer ${config.pinataJwt}`,
-      Source: "sdk/pinJobs"
+      "Content-Type": "application/json",
+      Source: "sdk/createKey"
     };
   }
+  const data = JSON.stringify(options);
+  let endpoint = "https://api.pinata.cloud/v3";
+  if (config.endpointUrl) {
+    endpoint = config.endpointUrl;
+  }
   try {
-    const request = await fetch(url, {
-      method: "GET",
-      headers
+    const request = await fetch(`${endpoint}/pinata/keys`, {
+      method: "POST",
+      headers,
+      body: data
     });
     if (!request.ok) {
       const errorData = await request.text();
@@ -984,41 +664,59 @@ var pinJobs = async (config, options) => {
       );
     }
     const res = await request.json();
-    return res.rows;
+    return res;
   } catch (error) {
     if (error instanceof PinataError) {
       throw error;
     }
     if (error instanceof Error) {
-      throw new PinataError(`Error processing pinJobs: ${error.message}`);
+      throw new PinataError(`Error processing createKey: ${error.message}`);
     }
-    throw new PinataError("An unknown error occurred while listing pin jobs");
+    throw new PinataError("An unknown error occurred while creating API key");
   }
 };
 
-// src/core/data/pinnedFileUsage.ts
-var pinnedFileCount = async (config) => {
+// src/core/keys/listKeys.ts
+var listKeys = async (config, options) => {
   if (!config) {
     throw new ValidationError("Pinata configuration is missing");
   }
-  let endpoint = "https://api.pinata.cloud";
-  if (config.endpointUrl) {
-    endpoint = config.endpointUrl;
-  }
   let headers;
   if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
     headers = { ...config.customHeaders };
   } else {
     headers = {
       Authorization: `Bearer ${config.pinataJwt}`,
-      Source: "sdk/pinnedFileUsage"
+      "Content-Type": "application/json",
+      Source: "sdk/listKeys"
     };
   }
+  const params = new URLSearchParams();
+  if (options) {
+    const { offset, name, revoked, limitedUse, exhausted } = options;
+    if (offset)
+      params.append("offset", offset.toString());
+    if (revoked !== void 0)
+      params.append("revoked", revoked.toString());
+    if (limitedUse !== void 0)
+      params.append("limitedUse", limitedUse.toString());
+    if (exhausted !== void 0)
+      params.append("exhausted", exhausted.toString());
+    if (name)
+      params.append("name", name);
+  }
+  let endpoint = "https://api.pinata.cloud/v3";
+  if (config.endpointUrl) {
+    endpoint = config.endpointUrl;
+  }
   try {
-    const request = await fetch(`${endpoint}/data/userPinnedDataTotal`, {
-      method: "GET",
-      headers
-    });
+    const request = await fetch(
+      `${endpoint}/pinata/keys?${params.toString()}`,
+      {
+        method: "GET",
+        headers
+      }
+    );
     if (!request.ok) {
       const errorData = await request.text();
       if (request.status === 401 || request.status === 403) {
@@ -1035,207 +733,25 @@ var pinnedFileCount = async (config) => {
       );
     }
     const res = await request.json();
-    return res.pin_count;
+    return res.keys;
   } catch (error) {
     if (error instanceof PinataError) {
       throw error;
     }
     if (error instanceof Error) {
-      throw new PinataError(
-        `Error processing pinnedFileUsage: ${error.message}`
-      );
+      throw new PinataError(`Error processing listKeys: ${error.message}`);
     }
-    throw new PinataError(
-      "An unknown error occurred while getting pinned file usage"
-    );
+    throw new PinataError("An unknown error occurred while listing API keys");
   }
 };
 
-// src/core/data/totalStorageUsage.ts
-var totalStorageUsage = async (config) => {
-  if (!config) {
-    throw new ValidationError("Pinata configuration is missing");
-  }
-  let endpoint = "https://api.pinata.cloud";
-  if (config.endpointUrl) {
-    endpoint = config.endpointUrl;
-  }
-  let headers;
-  if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
-    headers = { ...config.customHeaders };
-  } else {
-    headers = {
-      Authorization: `Bearer ${config.pinataJwt}`,
-      Source: "sdk/totalStorageUsage"
-    };
-  }
-  try {
-    const request = await fetch(`${endpoint}/data/userPinnedDataTotal`, {
-      method: "GET",
-      headers
-    });
-    if (!request.ok) {
-      const errorData = await request.text();
-      if (request.status === 401 || request.status === 403) {
-        throw new AuthenticationError(
-          `Authentication failed: ${errorData}`,
-          request.status,
-          errorData
-        );
-      }
-      throw new NetworkError(
-        `HTTP error: ${errorData}`,
-        request.status,
-        errorData
-      );
-    }
-    const res = await request.json();
-    return res.pin_size_total;
-  } catch (error) {
-    if (error instanceof PinataError) {
-      throw error;
-    }
-    if (error instanceof Error) {
-      throw new PinataError(
-        `Error processing totalStorageUsage: ${error.message}`
-      );
-    }
-    throw new PinataError(
-      "An unknown error occurred while getting total storage usage"
-    );
-  }
-};
-
-// src/core/keys/createKey.ts
-var createKey = async (config, options) => {
-  if (!config) {
-    throw new ValidationError("Pinata configuration is missing");
-  }
-  let headers;
-  if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
-    headers = { ...config.customHeaders };
-  } else {
-    headers = {
-      Authorization: `Bearer ${config.pinataJwt}`,
-      "Content-Type": "application/json",
-      Source: "sdk/createKey"
-    };
-  }
-  const data = JSON.stringify(options);
-  let endpoint = "https://api.pinata.cloud";
-  if (config.endpointUrl) {
-    endpoint = config.endpointUrl;
-  }
-  try {
-    const request = await fetch(`${endpoint}/v3/pinata/keys`, {
-      method: "POST",
-      headers,
-      body: data
-    });
-    if (!request.ok) {
-      const errorData = await request.text();
-      if (request.status === 401 || request.status === 403) {
-        throw new AuthenticationError(
-          `Authentication failed: ${errorData}`,
-          request.status,
-          errorData
-        );
-      }
-      throw new NetworkError(
-        `HTTP error: ${errorData}`,
-        request.status,
-        errorData
-      );
-    }
-    const res = await request.json();
-    return res;
-  } catch (error) {
-    if (error instanceof PinataError) {
-      throw error;
-    }
-    if (error instanceof Error) {
-      throw new PinataError(`Error processing createKey: ${error.message}`);
-    }
-    throw new PinataError("An unknown error occurred while creating API key");
-  }
-};
-
-// src/core/keys/listKeys.ts
-var listKeys = async (config, options) => {
-  if (!config) {
-    throw new ValidationError("Pinata configuration is missing");
-  }
-  let headers;
-  if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
-    headers = { ...config.customHeaders };
-  } else {
-    headers = {
-      Authorization: `Bearer ${config.pinataJwt}`,
-      "Content-Type": "application/json",
-      Source: "sdk/listKeys"
-    };
-  }
-  const params = new URLSearchParams();
-  if (options) {
-    const { offset, name, revoked, limitedUse, exhausted } = options;
-    if (offset)
-      params.append("offset", offset.toString());
-    if (revoked !== void 0)
-      params.append("revoked", revoked.toString());
-    if (limitedUse !== void 0)
-      params.append("limitedUse", limitedUse.toString());
-    if (exhausted !== void 0)
-      params.append("exhausted", exhausted.toString());
-    if (name)
-      params.append("name", name);
-  }
-  let endpoint = "https://api.pinata.cloud";
-  if (config.endpointUrl) {
-    endpoint = config.endpointUrl;
-  }
-  try {
-    const request = await fetch(
-      `${endpoint}/v3/pinata/keys?${params.toString()}`,
-      {
-        method: "GET",
-        headers
-      }
-    );
-    if (!request.ok) {
-      const errorData = await request.text();
-      if (request.status === 401 || request.status === 403) {
-        throw new AuthenticationError(
-          `Authentication failed: ${errorData}`,
-          request.status,
-          errorData
-        );
-      }
-      throw new NetworkError(
-        `HTTP error: ${errorData}`,
-        request.status,
-        errorData
-      );
-    }
-    const res = await request.json();
-    return res.keys;
-  } catch (error) {
-    if (error instanceof PinataError) {
-      throw error;
-    }
-    if (error instanceof Error) {
-      throw new PinataError(`Error processing listKeys: ${error.message}`);
-    }
-    throw new PinataError("An unknown error occurred while listing API keys");
-  }
-};
-
-// src/core/keys/revokeKeys.ts
-var wait2 = (milliseconds) => {
-  return new Promise((resolve) => {
-    setTimeout(resolve, milliseconds);
-  });
-};
-var revokeKeys = async (config, keys) => {
+// src/core/keys/revokeKeys.ts
+var wait2 = (milliseconds) => {
+  return new Promise((resolve) => {
+    setTimeout(resolve, milliseconds);
+  });
+};
+var revokeKeys = async (config, keys) => {
   if (!config) {
     throw new ValidationError("Pinata configuration is missing");
   }
@@ -1250,13 +766,13 @@ var revokeKeys = async (config, keys) => {
     };
   }
   const responses = [];
-  let endpoint = "https://api.pinata.cloud";
+  let endpoint = "https://api.pinata.cloud/v3";
   if (config.endpointUrl) {
     endpoint = config.endpointUrl;
   }
   for (const key of keys) {
     try {
-      const request = await fetch(`${endpoint}/v3/pinata/keys/${key}`, {
+      const request = await fetch(`${endpoint}/pinata/keys/${key}`, {
         method: "PUT",
         headers
       });
@@ -1304,7 +820,10 @@ var createGroup = async (config, options) => {
   if (!config) {
     throw new ValidationError("Pinata configuration is missing");
   }
-  const data = JSON.stringify(options);
+  const data = JSON.stringify({
+    name: options.name,
+    is_public: options.isPublic
+  });
   let headers;
   if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
     headers = { ...config.customHeaders };
@@ -1315,12 +834,12 @@ var createGroup = async (config, options) => {
       Source: "sdk/createGroup"
     };
   }
-  let endpoint = "https://api.pinata.cloud";
+  let endpoint = "https://api.pinata.cloud/v3";
   if (config.endpointUrl) {
     endpoint = config.endpointUrl;
   }
   try {
-    const request = await fetch(`${endpoint}/groups`, {
+    const request = await fetch(`${endpoint}/files/groups`, {
       method: "POST",
       headers,
       body: data
@@ -1341,7 +860,8 @@ var createGroup = async (config, options) => {
       );
     }
     const res = await request.json();
-    return res;
+    const resData = res.data;
+    return resData;
   } catch (error) {
     if (error instanceof PinataError) {
       throw error;
@@ -1370,23 +890,28 @@ var listGroups = async (config, options) => {
   }
   const params = new URLSearchParams();
   if (options) {
-    const { offset, nameContains, limit } = options;
-    if (offset)
-      params.append("offset", offset.toString());
+    const { pageToken, nameContains, limit, isPublic } = options;
+    if (pageToken)
+      params.append("pageToken", pageToken.toString());
+    if (isPublic)
+      params.append("isPublic", isPublic.toString());
     if (nameContains !== void 0)
       params.append("nameContains", nameContains.toString());
     if (limit !== void 0)
       params.append("limit", limit.toString());
   }
-  let endpoint = "https://api.pinata.cloud";
+  let endpoint = "https://api.pinata.cloud/v3";
   if (config.endpointUrl) {
     endpoint = config.endpointUrl;
   }
   try {
-    const request = await fetch(`${endpoint}/groups?${params.toString()}`, {
-      method: "GET",
-      headers
-    });
+    const request = await fetch(
+      `${endpoint}/files/groups?${params.toString()}`,
+      {
+        method: "GET",
+        headers
+      }
+    );
     if (!request.ok) {
       const errorData = await request.text();
       if (request.status === 401 || request.status === 403) {
@@ -1403,7 +928,8 @@ var listGroups = async (config, options) => {
       );
     }
     const res = await request.json();
-    return res;
+    const resData = res.data;
+    return resData;
   } catch (error) {
     if (error instanceof PinataError) {
       throw error;
@@ -1430,12 +956,12 @@ var getGroup = async (config, options) => {
       Source: "sdk/getGroup"
     };
   }
-  let endpoint = "https://api.pinata.cloud";
+  let endpoint = "https://api.pinata.cloud/v3";
   if (config.endpointUrl) {
     endpoint = config.endpointUrl;
   }
   try {
-    const request = await fetch(`${endpoint}/groups/${options.groupId}`, {
+    const request = await fetch(`${endpoint}/files/groups/${options.groupId}`, {
       method: "GET",
       headers
     });
@@ -1455,7 +981,8 @@ var getGroup = async (config, options) => {
       );
     }
     const res = await request.json();
-    return res;
+    const resData = res.data;
+    return resData;
   } catch (error) {
     if (error instanceof PinataError) {
       throw error;
@@ -1469,71 +996,14 @@ var getGroup = async (config, options) => {
   }
 };
 
-// src/core/groups/addToGroup.ts
-var addToGroup = async (config, options) => {
-  if (!config) {
-    throw new ValidationError("Pinata configuration is missing");
-  }
-  const data = JSON.stringify({
-    cids: options.cids
-  });
-  let headers;
-  if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
-    headers = { ...config.customHeaders };
-  } else {
-    headers = {
-      Authorization: `Bearer ${config.pinataJwt}`,
-      "Content-Type": "application/json",
-      Source: "sdk/addToGroup"
-    };
-  }
-  let endpoint = "https://api.pinata.cloud";
-  if (config.endpointUrl) {
-    endpoint = config.endpointUrl;
-  }
-  try {
-    const request = await fetch(`${endpoint}/groups/${options.groupId}/cids`, {
-      method: "PUT",
-      headers,
-      body: data
-    });
-    if (!request.ok) {
-      const errorData = await request.text();
-      if (request.status === 401 || request.status === 403) {
-        throw new AuthenticationError(
-          `Authentication failed: ${errorData}`,
-          request.status,
-          errorData
-        );
-      }
-      throw new NetworkError(
-        `HTTP error: ${errorData}`,
-        request.status,
-        errorData
-      );
-    }
-    const res = await request.text();
-    return res;
-  } catch (error) {
-    if (error instanceof PinataError) {
-      throw error;
-    }
-    if (error instanceof Error) {
-      throw new PinataError(`Error processing addToGroup: ${error.message}`);
-    }
-    throw new PinataError(
-      "An unknown error occurred while adding CIDs to group"
-    );
-  }
-};
-
 // src/core/groups/updateGroup.ts
 var updateGroup = async (config, options) => {
   if (!config) {
     throw new ValidationError("Pinata configuration is missing");
   }
   const data = JSON.stringify({
-    name: options.name
+    name: options.name,
+    is_public: options.isPublic
   });
   let headers;
   if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
@@ -1545,559 +1015,12 @@ var updateGroup = async (config, options) => {
       Source: "sdk/updateGroup"
     };
   }
-  let endpoint = "https://api.pinata.cloud";
-  if (config.endpointUrl) {
-    endpoint = config.endpointUrl;
-  }
-  try {
-    const request = await fetch(`${endpoint}/groups/${options.groupId}`, {
-      method: "PUT",
-      headers,
-      body: data
-    });
-    if (!request.ok) {
-      const errorData = await request.text();
-      if (request.status === 401 || request.status === 403) {
-        throw new AuthenticationError(
-          `Authentication failed: ${errorData}`,
-          request.status,
-          errorData
-        );
-      }
-      throw new NetworkError(
-        `HTTP error: ${errorData}`,
-        request.status,
-        errorData
-      );
-    }
-    const res = await request.json();
-    return res;
-  } catch (error) {
-    if (error instanceof PinataError) {
-      throw error;
-    }
-    if (error instanceof Error) {
-      throw new PinataError(`Error processing updateGroup: ${error.message}`);
-    }
-    throw new PinataError("An unknown error occurred while updating group");
-  }
-};
-
-// src/core/groups/removeFromGroup.ts
-var removeFromGroup = async (config, options) => {
-  if (!config) {
-    throw new ValidationError("Pinata configuration is missing");
-  }
-  let headers;
-  if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
-    headers = { ...config.customHeaders };
-  } else {
-    headers = {
-      Authorization: `Bearer ${config.pinataJwt}`,
-      "Content-Type": "application/json",
-      Source: "sdk/removeFromGroup"
-    };
-  }
-  const data = JSON.stringify({
-    cids: options.cids
-  });
-  let endpoint = "https://api.pinata.cloud";
-  if (config.endpointUrl) {
-    endpoint = config.endpointUrl;
-  }
-  try {
-    const request = await fetch(`${endpoint}/groups/${options.groupId}/cids`, {
-      method: "DELETE",
-      headers,
-      body: data
-    });
-    if (!request.ok) {
-      const errorData = await request.text();
-      if (request.status === 401 || request.status === 403) {
-        throw new AuthenticationError(
-          `Authentication failed: ${errorData}`,
-          request.status,
-          errorData
-        );
-      }
-      throw new NetworkError(
-        `HTTP error: ${errorData}`,
-        request.status,
-        errorData
-      );
-    }
-    const res = await request.text();
-    return res;
-  } catch (error) {
-    if (error instanceof PinataError) {
-      throw error;
-    }
-    if (error instanceof Error) {
-      throw new PinataError(
-        `Error processing removeFromGroup: ${error.message}`
-      );
-    }
-    throw new PinataError(
-      "An unknown error occurred while removing CIDs from a group"
-    );
-  }
-};
-
-// src/core/groups/deleteGroup.ts
-var deleteGroup = async (config, options) => {
-  if (!config) {
-    throw new ValidationError("Pinata configuration is missing");
-  }
-  let headers;
-  if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
-    headers = { ...config.customHeaders };
-  } else {
-    headers = {
-      Authorization: `Bearer ${config.pinataJwt}`,
-      "Content-Type": "application/json",
-      Source: "sdk/deleteGroup"
-    };
-  }
-  let endpoint = "https://api.pinata.cloud";
-  if (config.endpointUrl) {
-    endpoint = config.endpointUrl;
-  }
-  try {
-    const request = await fetch(`${endpoint}/groups/${options.groupId}`, {
-      method: "DELETE",
-      headers
-    });
-    if (!request.ok) {
-      const errorData = await request.text();
-      if (request.status === 401 || request.status === 403) {
-        throw new AuthenticationError(
-          `Authentication failed: ${errorData}`,
-          request.status,
-          errorData
-        );
-      }
-      throw new NetworkError(
-        `HTTP error: ${errorData}`,
-        request.status,
-        errorData
-      );
-    }
-    const res = await request.text();
-    return res;
-  } catch (error) {
-    if (error instanceof PinataError) {
-      throw error;
-    }
-    if (error instanceof Error) {
-      throw new PinataError(`Error processing deleteGroup: ${error.message}`);
-    }
-    throw new PinataError("An unknown error occurred while deleting a group");
-  }
-};
-
-// src/core/signatures/addSignature.ts
-var addSignature = async (config, options) => {
-  if (!config) {
-    throw new ValidationError("Pinata configuration is missing");
-  }
-  const data = JSON.stringify({
-    signature: options.signature
-  });
-  let headers;
-  if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
-    headers = { ...config.customHeaders };
-  } else {
-    headers = {
-      Authorization: `Bearer ${config.pinataJwt}`,
-      "Content-Type": "application/json",
-      Source: "sdk/addSignature"
-    };
-  }
-  let endpoint = "https://api.pinata.cloud";
-  if (config.endpointUrl) {
-    endpoint = config.endpointUrl;
-  }
-  try {
-    const request = await fetch(
-      `${endpoint}/v3/ipfs/signature/${options.cid}`,
-      {
-        method: "POST",
-        headers,
-        body: data
-      }
-    );
-    if (!request.ok) {
-      const errorData = await request.text();
-      if (request.status === 401 || request.status === 403) {
-        throw new AuthenticationError(
-          `Authentication failed: ${errorData}`,
-          request.status,
-          errorData
-        );
-      }
-      if (request.status === 403) {
-        throw new PinataError(
-          "Unauthorized signing, you must be the original owner of the file and it must not have a signature",
-          request.status,
-          errorData
-        );
-      }
-      throw new NetworkError(
-        `HTTP error: ${errorData}`,
-        request.status,
-        errorData
-      );
-    }
-    const res = await request.json();
-    return res.data;
-  } catch (error) {
-    if (error instanceof PinataError) {
-      throw error;
-    }
-    if (error instanceof Error) {
-      throw new PinataError(`Error processing addSignature: ${error.message}`);
-    }
-    throw new PinataError(
-      "An unknown error occurred while adding signature to CID"
-    );
-  }
-};
-
-// src/core/signatures/getSignature.ts
-var getSignature = async (config, cid) => {
-  if (!config) {
-    throw new ValidationError("Pinata configuration is missing");
-  }
-  let headers;
-  if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
-    headers = { ...config.customHeaders };
-  } else {
-    headers = {
-      Authorization: `Bearer ${config.pinataJwt}`,
-      "Content-Type": "application/json",
-      Source: "sdk/getSignature"
-    };
-  }
-  let endpoint = "https://api.pinata.cloud";
-  if (config.endpointUrl) {
-    endpoint = config.endpointUrl;
-  }
-  try {
-    const request = await fetch(`${endpoint}/v3/ipfs/signature/${cid}`, {
-      method: "GET",
-      headers
-    });
-    if (!request.ok) {
-      const errorData = await request.text();
-      if (request.status === 401 || request.status === 403) {
-        throw new AuthenticationError(
-          `Authentication failed: ${errorData}`,
-          request.status,
-          errorData
-        );
-      }
-      throw new NetworkError(
-        `HTTP error: ${errorData}`,
-        request.status,
-        errorData
-      );
-    }
-    const res = await request.json();
-    return res.data;
-  } catch (error) {
-    if (error instanceof PinataError) {
-      throw error;
-    }
-    if (error instanceof Error) {
-      throw new PinataError(`Error processing getSignature: ${error.message}`);
-    }
-    throw new PinataError(
-      "An unknown error occurred while fetching signature for CID"
-    );
-  }
-};
-
-// src/core/signatures/removeSignature.ts
-var removeSignature = async (config, cid) => {
-  if (!config) {
-    throw new ValidationError("Pinata configuration is missing");
-  }
-  let headers;
-  if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
-    headers = { ...config.customHeaders };
-  } else {
-    headers = {
-      Authorization: `Bearer ${config.pinataJwt}`,
-      "Content-Type": "application/json",
-      Source: "sdk/removeSignature"
-    };
-  }
-  let endpoint = "https://api.pinata.cloud";
-  if (config.endpointUrl) {
-    endpoint = config.endpointUrl;
-  }
-  try {
-    const request = await fetch(`${endpoint}/v3/ipfs/signature/${cid}`, {
-      method: "DELETE",
-      headers
-    });
-    if (!request.ok) {
-      const errorData = await request.text();
-      if (request.status === 401 || request.status === 403) {
-        throw new AuthenticationError(
-          `Authentication failed: ${errorData}`,
-          request.status,
-          errorData
-        );
-      }
-      throw new NetworkError(
-        `HTTP error: ${errorData}`,
-        request.status,
-        errorData
-      );
-    }
-    return "OK";
-  } catch (error) {
-    if (error instanceof PinataError) {
-      throw error;
-    }
-    if (error instanceof Error) {
-      throw new PinataError(`Error processing addSignature: ${error.message}`);
-    }
-    throw new PinataError(
-      "An unknown error occurred while adding signature to CID"
-    );
-  }
-};
-
-// src/core/gateway/analyticsTopUsage.ts
-var analyticsTopUsage = async (config, options) => {
-  if (!config) {
-    throw new ValidationError("Pinata configuration is missing");
-  }
-  const params = new URLSearchParams({
-    includesCount: "false"
-  });
-  if (options) {
-    const {
-      cid,
-      gateway_domain,
-      start_date,
-      end_date,
-      file_name,
-      user_agent,
-      country,
-      region,
-      referer,
-      limit,
-      sort_order,
-      sort_by,
-      attribute
-    } = options;
-    if (cid)
-      params.append("cid", cid);
-    if (gateway_domain)
-      params.append("gateway_domain", gateway_domain);
-    if (start_date)
-      params.append("start_date", start_date);
-    if (end_date)
-      params.append("end_date", end_date);
-    if (file_name)
-      params.append("file_name", file_name);
-    if (user_agent)
-      params.append("user_agent", user_agent.toString());
-    if (country)
-      params.append("country", country.toString());
-    if (region)
-      params.append("region", region);
-    if (referer)
-      params.append("referer", referer.toString());
-    if (limit)
-      params.append("limit", limit.toString());
-    if (sort_order)
-      params.append("sort_order", sort_order);
-    if (sort_by)
-      params.append("sort_by", sort_by);
-    if (attribute)
-      params.append("by", attribute);
-  }
-  let endpoint = "https://api.pinata.cloud";
-  if (config.endpointUrl) {
-    endpoint = config.endpointUrl;
-  }
-  const url = `${endpoint}/v3/ipfs/gateway_analytics_top?${params.toString()}`;
-  try {
-    let headers;
-    if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
-      headers = { ...config.customHeaders };
-    } else {
-      headers = {
-        Authorization: `Bearer ${config.pinataJwt}`,
-        Source: "sdk/analyticsTopUsage"
-      };
-    }
-    const request = await fetch(url, {
-      method: "GET",
-      headers
-    });
-    if (!request.ok) {
-      const errorData = await request.text();
-      if (request.status === 401 || request.status === 403) {
-        throw new AuthenticationError(
-          `Authentication failed: ${errorData}`,
-          request.status,
-          errorData
-        );
-      }
-      throw new NetworkError(
-        `HTTP error: ${errorData}`,
-        request.status,
-        errorData
-      );
-    }
-    const res = await request.json();
-    const resData = res.data;
-    return resData;
-  } catch (error) {
-    if (error instanceof PinataError) {
-      throw error;
-    }
-    if (error instanceof Error) {
-      throw new PinataError(
-        `Error processing anaytics usage: ${error.message}`
-      );
-    }
-    throw new PinataError(
-      "An unknown error occurred while fetching gateway usage"
-    );
-  }
-};
-
-// src/core/gateway/analyticsDateInterval.ts
-var analyticsDateInterval = async (config, options) => {
-  if (!config) {
-    throw new ValidationError("Pinata configuration is missing");
-  }
-  const params = new URLSearchParams();
-  if (options) {
-    const {
-      cid,
-      gateway_domain,
-      start_date,
-      end_date,
-      file_name,
-      user_agent,
-      country,
-      region,
-      referer,
-      limit,
-      sort_order,
-      date_interval,
-      sort_by
-    } = options;
-    if (cid)
-      params.append("cid", cid);
-    if (gateway_domain)
-      params.append("gateway_domain", gateway_domain);
-    if (start_date)
-      params.append("start_date", start_date);
-    if (end_date)
-      params.append("end_date", end_date);
-    if (file_name)
-      params.append("file_name", file_name);
-    if (user_agent)
-      params.append("user_agent", user_agent.toString());
-    if (country)
-      params.append("country", country.toString());
-    if (region)
-      params.append("region", region);
-    if (referer)
-      params.append("referer", referer.toString());
-    if (limit)
-      params.append("limit", limit.toString());
-    if (sort_order)
-      params.append("sort_order", sort_order);
-    if (sort_by)
-      params.append("sort_by", sort_by);
-    if (date_interval)
-      params.append("by", date_interval);
-  }
-  let endpoint = "https://api.pinata.cloud";
-  if (config.endpointUrl) {
-    endpoint = config.endpointUrl;
-  }
-  const url = `${endpoint}/v3/ipfs/gateway_analytics_time_series?${params.toString()}`;
-  try {
-    let headers;
-    if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
-      headers = { ...config.customHeaders };
-    } else {
-      headers = {
-        Authorization: `Bearer ${config.pinataJwt}`,
-        Source: "sdk/analyticsDateInterval"
-      };
-    }
-    const request = await fetch(url, {
-      method: "GET",
-      headers
-    });
-    if (!request.ok) {
-      const errorData = await request.text();
-      if (request.status === 401 || request.status === 403) {
-        throw new AuthenticationError(
-          `Authentication failed: ${errorData}`,
-          request.status,
-          errorData
-        );
-      }
-      throw new NetworkError(
-        `HTTP error: ${errorData}`,
-        request.status,
-        errorData
-      );
-    }
-    const res = await request.json();
-    const resData = res.data;
-    return resData;
-  } catch (error) {
-    if (error instanceof PinataError) {
-      throw error;
-    }
-    if (error instanceof Error) {
-      throw new PinataError(
-        `Error processing anaytics usage: ${error.message}`
-      );
-    }
-    throw new PinataError(
-      "An unknown error occurred while fetching gateway usage"
-    );
-  }
-};
-
-// src/core/gateway/swapCid.ts
-var swapCid = async (config, options) => {
-  if (!config) {
-    throw new ValidationError("Pinata configuration is missing");
-  }
-  const data = JSON.stringify({
-    swapCid: options.swapCid
-  });
-  let headers;
-  if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
-    headers = { ...config.customHeaders };
-  } else {
-    headers = {
-      Authorization: `Bearer ${config.pinataJwt}`,
-      "Content-Type": "application/json",
-      Source: "sdk/swapCid"
-    };
-  }
-  let endpoint = "https://api.pinata.cloud";
+  let endpoint = "https://api.pinata.cloud/v3";
   if (config.endpointUrl) {
     endpoint = config.endpointUrl;
   }
   try {
-    const request = await fetch(`${endpoint}/v3/ipfs/swap/${options.cid}`, {
+    const request = await fetch(`${endpoint}/files/groups/${options.groupId}`, {
       method: "PUT",
       headers,
       body: data
@@ -2111,20 +1034,6 @@ var swapCid = async (config, options) => {
           errorData
         );
       }
-      if (request.status === 403) {
-        throw new PinataError(
-          "Unauthorized CID Swap",
-          request.status,
-          errorData
-        );
-      }
-      if (request.status === 404) {
-        throw new PinataError(
-          "CID not pinned to account",
-          request.status,
-          errorData
-        );
-      }
       throw new NetworkError(
         `HTTP error: ${errorData}`,
         request.status,
@@ -2139,14 +1048,14 @@ var swapCid = async (config, options) => {
       throw error;
     }
     if (error instanceof Error) {
-      throw new PinataError(`Error processing CID Swap: ${error.message}`);
+      throw new PinataError(`Error processing updateGroup: ${error.message}`);
     }
-    throw new PinataError("An unknown error occurred while swapping CID");
+    throw new PinataError("An unknown error occurred while updating group");
   }
 };
 
-// src/core/gateway/swapHistory.ts
-var swapHistory = async (config, options) => {
+// src/core/groups/deleteGroup.ts
+var deleteGroup = async (config, options) => {
   if (!config) {
     throw new ValidationError("Pinata configuration is missing");
   }
@@ -2157,21 +1066,18 @@ var swapHistory = async (config, options) => {
     headers = {
       Authorization: `Bearer ${config.pinataJwt}`,
       "Content-Type": "application/json",
-      Source: "sdk/swapHistory"
+      Source: "sdk/deleteGroup"
     };
   }
-  let endpoint = "https://api.pinata.cloud";
+  let endpoint = "https://api.pinata.cloud/v3";
   if (config.endpointUrl) {
     endpoint = config.endpointUrl;
   }
   try {
-    const request = await fetch(
-      `${endpoint}/v3/ipfs/swap/${options.cid}?domain=${options.domain}`,
-      {
-        method: "GET",
-        headers
-      }
-    );
+    const request = await fetch(`${endpoint}/files/groups/${options.groupId}`, {
+      method: "DELETE",
+      headers
+    });
     if (!request.ok) {
       const errorData = await request.text();
       if (request.status === 401 || request.status === 403) {
@@ -2181,78 +1087,52 @@ var swapHistory = async (config, options) => {
           errorData
         );
       }
-      if (request.status === 404) {
-        throw new PinataError(
-          "CID does not have history",
-          request.status,
-          errorData
-        );
-      }
       throw new NetworkError(
         `HTTP error: ${errorData}`,
         request.status,
         errorData
       );
     }
-    const res = await request.json();
-    const resData = res.data;
-    return resData;
+    const res = request.statusText;
+    return res;
   } catch (error) {
     if (error instanceof PinataError) {
       throw error;
     }
     if (error instanceof Error) {
-      throw new PinataError(`Error fetching swap history: ${error.message}`);
+      throw new PinataError(`Error processing deleteGroup: ${error.message}`);
     }
-    throw new PinataError(
-      "An unknown error occurred while fetching swap history"
-    );
+    throw new PinataError("An unknown error occurred while deleting a group");
   }
 };
 
-// src/core/gateway/deleteSwap.ts
-var deleteSwap = async (config, cid) => {
+// src/core/gateway/createSignedURL.ts
+var createSignedURL = async (config, options) => {
   if (!config) {
     throw new ValidationError("Pinata configuration is missing");
   }
-  let headers;
-  if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
-    headers = { ...config.customHeaders };
-  } else {
-    headers = {
-      Authorization: `Bearer ${config.pinataJwt}`,
-      "Content-Type": "application/json",
-      Source: "sdk/deleteSwap"
-    };
-  }
-  let endpoint = "https://api.pinata.cloud";
-  if (config.endpointUrl) {
-    endpoint = config.endpointUrl;
-  }
+  let newUrl = `${config?.pinataGateway}/files/${options.cid}`;
+  const date = options?.date || Math.floor((/* @__PURE__ */ new Date()).getTime() / 1e3);
+  const payload = JSON.stringify({
+    url: newUrl,
+    date,
+    expires: options.expires,
+    method: "GET"
+  });
   try {
-    const request = await fetch(`${endpoint}/v3/ipfs/swap/${cid}`, {
-      method: "DELETE",
-      headers
+    const request = await fetch("https://api.pinata.cloud/v3/files/sign", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${config?.pinataJwt}`
+      },
+      body: payload
     });
     if (!request.ok) {
       const errorData = await request.text();
       if (request.status === 401 || request.status === 403) {
         throw new AuthenticationError(
-          `Authentication failed: ${errorData}`,
-          request.status,
-          errorData
-        );
-      }
-      if (request.status === 403) {
-        throw new PinataError(
-          "Unauthorized CID Swap Deletion",
-          request.status,
-          errorData
-        );
-      }
-      if (request.status === 404) {
-        throw new PinataError(
-          "CID not pinned to account",
+          `Authentication Failed: ${errorData}`,
           request.status,
           errorData
         );
@@ -2263,15 +1143,18 @@ var deleteSwap = async (config, cid) => {
         errorData
       );
     }
-    return request.statusText;
+    const res = await request.json();
+    return res.data;
   } catch (error) {
     if (error instanceof PinataError) {
       throw error;
     }
     if (error instanceof Error) {
-      throw new PinataError(`Error processing deleteSwap: ${error.message}`);
+      throw new PinataError(
+        `Error processing createSignedURL: ${error.message}`
+      );
     }
-    throw new PinataError("An unknown error occurred while deleting swap");
+    throw new PinataError("An unknown error occurred while getting signed url");
   }
 };
 
@@ -2287,41 +1170,45 @@ var formatConfig = (config) => {
   return config;
 };
 var PinataSDK = class {
+  //signatures: Signatures;
   constructor(config) {
     this.config = formatConfig(config);
+    this.files = new Files(this.config);
     this.upload = new Upload(this.config);
     this.gateways = new Gateways(this.config);
-    this.usage = new Usage(this.config);
     this.keys = new Keys(this.config);
     this.groups = new Groups(this.config);
-    this.signatures = new Signatures(this.config);
   }
   setNewHeaders(headers) {
     if (!this.config) {
       this.config = { pinataJwt: "", customHeaders: {} };
     }
     this.config.customHeaders = { ...this.config.customHeaders, ...headers };
+    this.files.updateConfig(this.config);
     this.upload.updateConfig(this.config);
     this.gateways.updateConfig(this.config);
-    this.usage.updateConfig(this.config);
     this.keys.updateConfig(this.config);
     this.groups.updateConfig(this.config);
-    this.signatures.updateConfig(this.config);
   }
   testAuthentication() {
     return testAuthentication(this.config);
   }
-  unpin(files) {
-    return unpinFile(this.config, files);
+};
+var Files = class {
+  constructor(config) {
+    this.config = formatConfig(config);
+  }
+  updateConfig(newConfig) {
+    this.config = newConfig;
   }
-  listFiles() {
+  list() {
     return new FilterFiles(this.config);
   }
-  updateMetadata(options) {
-    return updateMetadata(this.config, options);
+  delete(files) {
+    return deleteFile(this.config, files);
   }
-  pinJobs() {
-    return new FilterPinJobs(this.config);
+  update(options) {
+    return updateFile(this.config, options);
   }
 };
 var UploadBuilder = class {
@@ -2329,7 +1216,6 @@ var UploadBuilder = class {
     this.config = config;
     this.uploadFunction = uploadFunction;
     this.args = args;
-    this.version = 1;
   }
   addMetadata(metadata) {
     this.metadata = metadata;
@@ -2339,18 +1225,14 @@ var UploadBuilder = class {
     this.keys = jwt;
     return this;
   }
-  cidVersion(v) {
-    this.version = v;
-    return this;
-  }
+  // cidVersion(v: 0 | 1): UploadBuilder<T> {
+  // 	this.version = v;
+  // 	return this;
+  // }
   group(groupId) {
     this.groupId = groupId;
     return this;
   }
-  peerAddress(peerAddresses) {
-    this.peerAddresses = peerAddresses;
-    return this;
-  }
   then(onfulfilled, onrejected) {
     const options = this.args[this.args.length - 1] || {};
     if (this.metadata) {
@@ -2362,12 +1244,6 @@ var UploadBuilder = class {
     if (this.groupId) {
       options.groupId = this.groupId;
     }
-    if (this.version) {
-      options.cidVersion = this.version;
-    }
-    if (this.peerAddresses && "peerAddresses" in options) {
-      options.peerAddresses = this.peerAddresses;
-    }
     this.args[this.args.length - 1] = options;
     return this.uploadFunction(this.config, ...this.args).then(
       onfulfilled,
@@ -2385,9 +1261,12 @@ var Upload = class {
   file(file, options) {
     return new UploadBuilder(this.config, uploadFile, file, options);
   }
-  fileArray(files, options) {
-    return new UploadBuilder(this.config, uploadFileArray, files, options);
-  }
+  // fileArray(
+  // 	files: FileObject[],
+  // 	options?: UploadOptions,
+  // ): UploadBuilder<UploadResponse> {
+  // 	return new UploadBuilder(this.config, uploadFileArray, files, options);
+  // }
   base64(base64String, options) {
     return new UploadBuilder(this.config, uploadBase64, base64String, options);
   }
@@ -2397,97 +1276,58 @@ var Upload = class {
   json(data, options) {
     return new UploadBuilder(this.config, uploadJson, data, options);
   }
-  cid(cid, options) {
-    return new UploadBuilder(this.config, uploadCid, cid, options);
-  }
 };
 var FilterFiles = class {
+  // rate limit vars
+  // private requestCount = 0;
+  // private lastRequestTime = 0;
+  // private readonly MAX_REQUESTS_PER_MINUTE = 30;
+  // private readonly MINUTE_IN_MS = 60000;
   constructor(config) {
     this.query = {};
-    // rate limit vars
-    this.requestCount = 0;
-    this.lastRequestTime = 0;
-    this.MAX_REQUESTS_PER_MINUTE = 30;
-    this.MINUTE_IN_MS = 6e4;
     this.config = config;
   }
-  cid(cid) {
-    this.query.cid = cid;
-    return this;
-  }
-  pinStart(date) {
-    this.query.pinStart = date;
-    return this;
-  }
-  pinEnd(date) {
-    this.query.pinEnd = date;
-    return this;
-  }
-  pinSizeMin(size) {
-    this.query.pinSizeMin = size;
-    return this;
-  }
-  pinSizeMax(size) {
-    this.query.pinSizeMax = size;
-    return this;
-  }
-  pageLimit(limit) {
-    this.query.pageLimit = limit;
-    return this;
-  }
-  pageOffset(offset) {
-    this.query.pageOffset = offset;
-    return this;
-  }
-  name(name) {
-    this.query.name = name;
-    return this;
-  }
-  group(groupId) {
-    this.query.groupId = groupId;
+  limit(limit) {
+    this.query.limit = limit;
     return this;
   }
-  keyValue(key, value, operator) {
-    this.query.key = key;
-    this.query.value = value;
-    if (operator) {
-      this.query.operator = operator;
-    }
+  cidPending(cidPending) {
+    this.query.cidPending = cidPending;
     return this;
   }
   then(onfulfilled) {
-    return listFiles(this.config, this.query).then(onfulfilled);
-  }
-  // rate limit, hopefully temporary?
-  async rateLimit() {
-    this.requestCount++;
-    const now = Date.now();
-    if (this.requestCount >= this.MAX_REQUESTS_PER_MINUTE) {
-      const timePassedSinceLastRequest = now - this.lastRequestTime;
-      if (timePassedSinceLastRequest < this.MINUTE_IN_MS) {
-        const delayTime = this.MINUTE_IN_MS - timePassedSinceLastRequest;
-        await new Promise((resolve) => setTimeout(resolve, delayTime));
-      }
-      this.requestCount = 0;
-    }
-    this.lastRequestTime = Date.now();
-  }
+    return this.fetchPage().then(onfulfilled);
+  }
+  async fetchPage() {
+    if (this.currentPageToken) {
+      this.query.pageToken = this.currentPageToken;
+    }
+    const response = await listFiles(this.config, this.query);
+    this.currentPageToken = response.next_page_token;
+    return response.files;
+  }
+  // // rate limit, hopefully temporary?
+  // private async rateLimit(): Promise<void> {
+  // 	this.requestCount++;
+  // 	const now = Date.now();
+  // 	if (this.requestCount >= this.MAX_REQUESTS_PER_MINUTE) {
+  // 		const timePassedSinceLastRequest = now - this.lastRequestTime;
+  // 		if (timePassedSinceLastRequest < this.MINUTE_IN_MS) {
+  // 			const delayTime = this.MINUTE_IN_MS - timePassedSinceLastRequest;
+  // 			await new Promise((resolve) => setTimeout(resolve, delayTime));
+  // 		}
+  // 		this.requestCount = 0;
+  // 	}
+  // 	this.lastRequestTime = Date.now();
+  // }
   async *[Symbol.asyncIterator]() {
-    let hasMore = true;
-    let offset = 0;
-    const limit = this.query.pageLimit || 10;
-    while (hasMore) {
-      await this.rateLimit();
-      this.query.pageOffset = offset;
-      this.query.pageLimit = limit;
-      const items = await listFiles(this.config, this.query);
+    while (true) {
+      const items = await this.fetchPage();
       for (const item of items) {
         yield item;
       }
-      if (items.length === 0) {
-        hasMore = false;
-      } else {
-        offset += items.length;
+      if (!this.currentPageToken) {
+        break;
       }
     }
   }
@@ -2509,125 +1349,63 @@ var Gateways = class {
   get(cid) {
     return getCid(this.config, cid);
   }
-  convert(url) {
-    return convertIPFSUrl(this.config, url);
-  }
-  topUsageAnalytics(options) {
-    return new TopGatewayAnalyticsBuilder(
-      this.config,
-      options.domain,
-      options.start,
-      options.end,
-      options.sortBy,
-      options.attribute
-    );
-  }
-  dateIntervalAnalytics(options) {
-    return new TimeIntervalGatewayAnalyticsBuilder(
-      this.config,
-      options.domain,
-      options.start,
-      options.end,
-      options.interval
-    );
-  }
-  swapCid(options) {
-    return swapCid(this.config, options);
-  }
-  swapHistory(options) {
-    return swapHistory(this.config, options);
-  }
-  deleteSwap(cid) {
-    return deleteSwap(this.config, cid);
-  }
-};
-var FilterPinJobs = class {
-  constructor(config) {
-    this.query = {};
-    // rate limit vars
-    this.requestCount = 0;
-    this.lastRequestTime = 0;
-    this.MAX_REQUESTS_PER_MINUTE = 30;
-    this.MINUTE_IN_MS = 6e4;
-    this.config = config;
-  }
-  cid(cid) {
-    this.query.ipfs_pin_hash = cid;
-    return this;
-  }
-  status(status) {
-    this.query.status = status;
-    return this;
-  }
-  pageLimit(limit) {
-    this.query.limit = limit;
-    return this;
-  }
-  pageOffset(offset) {
-    this.query.offset = offset;
-    return this;
-  }
-  sort(sort) {
-    this.query.sort = sort;
-    return this;
-  }
-  then(onfulfilled) {
-    return pinJobs(this.config, this.query).then(onfulfilled);
-  }
-  // rate limit, hopefully temporary?
-  async rateLimit() {
-    this.requestCount++;
-    const now = Date.now();
-    if (this.requestCount >= this.MAX_REQUESTS_PER_MINUTE) {
-      const timePassedSinceLastRequest = now - this.lastRequestTime;
-      if (timePassedSinceLastRequest < this.MINUTE_IN_MS) {
-        const delayTime = this.MINUTE_IN_MS - timePassedSinceLastRequest;
-        await new Promise((resolve) => setTimeout(resolve, delayTime));
-      }
-      this.requestCount = 0;
-    }
-    this.lastRequestTime = Date.now();
-  }
-  async *[Symbol.asyncIterator]() {
-    let hasMore = true;
-    let offset = 0;
-    const limit = this.query.limit || 10;
-    while (hasMore) {
-      await this.rateLimit();
-      this.query.offset = offset;
-      this.query.limit = limit;
-      const items = await pinJobs(this.config, this.query);
-      for (const item of items) {
-        yield item;
-      }
-      if (items.length === 0) {
-        hasMore = false;
-      } else {
-        offset += items.length;
-      }
-    }
-  }
-  async all() {
-    const allItems = [];
-    for await (const item of this) {
-      allItems.push(item);
-    }
-    return allItems;
-  }
-};
-var Usage = class {
-  constructor(config) {
-    this.config = formatConfig(config);
-  }
-  updateConfig(newConfig) {
-    this.config = newConfig;
-  }
-  pinnedFileCount() {
-    return pinnedFileCount(this.config);
-  }
-  totalStorageSize() {
-    return totalStorageUsage(this.config);
-  }
+  createSignedURL(options) {
+    return createSignedURL(this.config, options);
+  }
+  // get(cid: string): OptimizeImage {
+  // 	return new OptimizeImage(this.config, cid);
+  // }
+  // convert(url: string, gatewayPrefix?: string): Promise<string> {
+  // 	return convertIPFSUrl(this.config, url, gatewayPrefix);
+  // }
+  // containsCID(cid: string): Promise<ContainsCIDResponse> {
+  // 	return containsCID(cid);
+  // }
+  // topUsageAnalytics(options: {
+  // 	domain: string;
+  // 	start: string;
+  // 	end: string;
+  // 	sortBy: "requests" | "bandwidth";
+  // 	attribute:
+  // 		| "cid"
+  // 		| "country"
+  // 		| "region"
+  // 		| "user_agent"
+  // 		| "referer"
+  // 		| "file_name";
+  // }): TopGatewayAnalyticsBuilder {
+  // 	return new TopGatewayAnalyticsBuilder(
+  // 		this.config,
+  // 		options.domain,
+  // 		options.start,
+  // 		options.end,
+  // 		options.sortBy,
+  // 		options.attribute,
+  // 	);
+  // }
+  // dateIntervalAnalytics(options: {
+  // 	domain: string;
+  // 	start: string;
+  // 	end: string;
+  // 	interval: "day" | "week";
+  // }): TimeIntervalGatewayAnalyticsBuilder {
+  // 	return new TimeIntervalGatewayAnalyticsBuilder(
+  // 		this.config,
+  // 		options.domain,
+  // 		options.start,
+  // 		options.end,
+  // 		options.interval,
+  // 	);
+  // }
+  // swapCid(options: SwapCidOptions): Promise<SwapCidResponse> {
+  // 	return swapCid(this.config, options);
+  // }
+  // swapHistory(options: SwapHistoryOptions): Promise<SwapCidResponse[]> {
+  // 	return swapHistory(this.config, options);
+  // }
+  // deleteSwap(cid: string): Promise<string> {
+  // 	return deleteSwap(this.config, cid);
+  // }
 };
 var Keys = class {
   constructor(config) {
@@ -2647,13 +1425,13 @@ var Keys = class {
   }
 };
 var FilterKeys = class {
+  // rate limit vars
+  // private requestCount = 0;
+  // private lastRequestTime = 0;
+  // private readonly MAX_REQUESTS_PER_MINUTE = 30;
+  // private readonly MINUTE_IN_MS = 60000;
   constructor(config) {
     this.query = {};
-    // rate limit vars
-    this.requestCount = 0;
-    this.lastRequestTime = 0;
-    this.MAX_REQUESTS_PER_MINUTE = 30;
-    this.MINUTE_IN_MS = 6e4;
     this.config = config;
   }
   offset(offset) {
@@ -2679,25 +1457,23 @@ var FilterKeys = class {
   then(onfulfilled) {
     return listKeys(this.config, this.query).then(onfulfilled);
   }
-  // rate limit, hopefully temporary?
-  async rateLimit() {
-    this.requestCount++;
-    const now = Date.now();
-    if (this.requestCount >= this.MAX_REQUESTS_PER_MINUTE) {
-      const timePassedSinceLastRequest = now - this.lastRequestTime;
-      if (timePassedSinceLastRequest < this.MINUTE_IN_MS) {
-        const delayTime = this.MINUTE_IN_MS - timePassedSinceLastRequest;
-        await new Promise((resolve) => setTimeout(resolve, delayTime));
-      }
-      this.requestCount = 0;
-    }
-    this.lastRequestTime = Date.now();
-  }
+  // private async rateLimit(): Promise<void> {
+  // 	this.requestCount++;
+  // 	const now = Date.now();
+  // 	if (this.requestCount >= this.MAX_REQUESTS_PER_MINUTE) {
+  // 		const timePassedSinceLastRequest = now - this.lastRequestTime;
+  // 		if (timePassedSinceLastRequest < this.MINUTE_IN_MS) {
+  // 			const delayTime = this.MINUTE_IN_MS - timePassedSinceLastRequest;
+  // 			await new Promise((resolve) => setTimeout(resolve, delayTime));
+  // 		}
+  // 		this.requestCount = 0;
+  // 	}
+  // 	this.lastRequestTime = Date.now();
+  // }
   async *[Symbol.asyncIterator]() {
     let hasMore = true;
     let offset = 0;
     while (hasMore) {
-      await this.rateLimit();
       this.query.offset = offset;
       const items = await listKeys(this.config, this.query);
       for (const item of items) {
@@ -2734,12 +1510,12 @@ var Groups = class {
   get(options) {
     return getGroup(this.config, options);
   }
-  addCids(options) {
-    return addToGroup(this.config, options);
-  }
-  removeCids(options) {
-    return removeFromGroup(this.config, options);
-  }
+  // addFiles(options: GroupCIDOptions): Promise<string> {
+  // 	return addToGroup(this.config, options);
+  // }
+  // removeFiles(options: GroupCIDOptions): Promise<string> {
+  // 	return removeFromGroup(this.config, options);
+  // }
   update(options) {
     return updateGroup(this.config, options);
   }
@@ -2750,57 +1526,56 @@ var Groups = class {
 var FilterGroups = class {
   constructor(config) {
     this.query = {};
-    // rate limit vars
-    this.requestCount = 0;
-    this.lastRequestTime = 0;
-    this.MAX_REQUESTS_PER_MINUTE = 30;
-    this.MINUTE_IN_MS = 6e4;
     this.config = config;
   }
-  offset(offset) {
-    this.query.offset = offset;
-    return this;
-  }
-  name(nameContains) {
-    this.query.nameContains = nameContains;
-    return this;
-  }
+  // name(nameContains: string): FilterGroups {
+  // 	this.query.nameContains = nameContains;
+  // 	return this;
+  // }
   limit(limit) {
     this.query.limit = limit;
     return this;
   }
+  isPublic(isPublic) {
+    this.query.isPublic = isPublic;
+    return this;
+  }
   then(onfulfilled) {
-    return listGroups(this.config, this.query).then(onfulfilled);
+    return this.fetchPage().then((response) => {
+      this.nextPageToken = response.next_page_token;
+      return response.groups;
+    }).then(onfulfilled);
   }
-  // rate limit, hopefully temporary?
-  async rateLimit() {
-    this.requestCount++;
-    const now = Date.now();
-    if (this.requestCount >= this.MAX_REQUESTS_PER_MINUTE) {
-      const timePassedSinceLastRequest = now - this.lastRequestTime;
-      if (timePassedSinceLastRequest < this.MINUTE_IN_MS) {
-        const delayTime = this.MINUTE_IN_MS - timePassedSinceLastRequest;
-        await new Promise((resolve) => setTimeout(resolve, delayTime));
-      }
-      this.requestCount = 0;
+  async fetchPage() {
+    if (this.nextPageToken) {
+      this.query.pageToken = this.nextPageToken;
     }
-    this.lastRequestTime = Date.now();
+    return listGroups(this.config, this.query);
   }
+  // rate limit, hopefully temporary?
+  // private async rateLimit(): Promise<void> {
+  // 	this.requestCount++;
+  // 	const now = Date.now();
+  // 	if (this.requestCount >= this.MAX_REQUESTS_PER_MINUTE) {
+  // 		const timePassedSinceLastRequest = now - this.lastRequestTime;
+  // 		if (timePassedSinceLastRequest < this.MINUTE_IN_MS) {
+  // 			const delayTime = this.MINUTE_IN_MS - timePassedSinceLastRequest;
+  // 			await new Promise((resolve) => setTimeout(resolve, delayTime));
+  // 		}
+  // 		this.requestCount = 0;
+  // 	}
+  // 	this.lastRequestTime = Date.now();
+  // }
   async *[Symbol.asyncIterator]() {
-    let hasMore = true;
-    let offset = 0;
-    while (hasMore) {
-      await this.rateLimit();
-      this.query.offset = offset;
-      const items = await listGroups(this.config, this.query);
-      for (const item of items) {
+    while (true) {
+      const response = await this.fetchPage();
+      for (const item of response.groups) {
         yield item;
       }
-      if (items.length === 0) {
-        hasMore = false;
-      } else {
-        offset += items.length;
+      if (!response.next_page_token) {
+        break;
       }
+      this.nextPageToken = response.next_page_token;
     }
   }
   async all() {
@@ -2811,122 +1586,6 @@ var FilterGroups = class {
     return allItems;
   }
 };
-var Signatures = class {
-  constructor(config) {
-    this.config = formatConfig(config);
-  }
-  updateConfig(newConfig) {
-    this.config = newConfig;
-  }
-  add(options) {
-    return addSignature(this.config, options);
-  }
-  get(cid) {
-    return getSignature(this.config, cid);
-  }
-  delete(cid) {
-    return removeSignature(this.config, cid);
-  }
-};
-var GatewayAnalyticsBuilder = class {
-  constructor(config, query) {
-    this.requestCount = 0;
-    this.lastRequestTime = 0;
-    this.MAX_REQUESTS_PER_MINUTE = 30;
-    this.MINUTE_IN_MS = 6e4;
-    this.config = config;
-    this.query = query;
-  }
-  cid(cid) {
-    this.query.cid = cid;
-    return this;
-  }
-  fileName(fileName) {
-    this.query.file_name = fileName;
-    return this;
-  }
-  userAgent(userAgent) {
-    this.query.user_agent = userAgent;
-    return this;
-  }
-  country(country) {
-    this.query.country = country;
-    return this;
-  }
-  region(region) {
-    this.query.region = region;
-    return this;
-  }
-  referer(referer) {
-    this.query.referer = referer;
-    return this;
-  }
-  limit(limit) {
-    this.query.limit = limit;
-    return this;
-  }
-  sort(order) {
-    this.query.sort_order = order;
-    return this;
-  }
-  async rateLimit() {
-    this.requestCount++;
-    const now = Date.now();
-    if (this.requestCount >= this.MAX_REQUESTS_PER_MINUTE) {
-      const timePassedSinceLastRequest = now - this.lastRequestTime;
-      if (timePassedSinceLastRequest < this.MINUTE_IN_MS) {
-        const delayTime = this.MINUTE_IN_MS - timePassedSinceLastRequest;
-        await new Promise((resolve) => setTimeout(resolve, delayTime));
-      }
-      this.requestCount = 0;
-    }
-    this.lastRequestTime = Date.now();
-  }
-  async getAnalytics() {
-    await this.rateLimit();
-    throw new Error("getAnalytics method must be implemented in derived class");
-  }
-  then(onfulfilled) {
-    return this.getAnalytics().then(onfulfilled);
-  }
-};
-var TopGatewayAnalyticsBuilder = class extends GatewayAnalyticsBuilder {
-  constructor(config, domain, start, end, sortBy, attribute) {
-    super(config, {
-      gateway_domain: domain,
-      start_date: start,
-      end_date: end,
-      sort_by: sortBy,
-      attribute
-    });
-  }
-  async getAnalytics() {
-    return analyticsTopUsage(this.config, this.query);
-  }
-  async all() {
-    return this.getAnalytics();
-  }
-};
-var TimeIntervalGatewayAnalyticsBuilder = class extends GatewayAnalyticsBuilder {
-  constructor(config, domain, start, end, dateInterval) {
-    super(config, {
-      gateway_domain: domain,
-      start_date: start,
-      end_date: end,
-      date_interval: dateInterval
-    });
-  }
-  sortBy(sortBy) {
-    this.query.sort_by = sortBy;
-    return this;
-  }
-  async getAnalytics() {
-    return analyticsDateInterval(this.config, this.query);
-  }
-  async all() {
-    return this.getAnalytics();
-  }
-};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   PinataSDK